🥮 mooncakes.io

lepusa

MoonBit-native desktop application framework research and implementation.

desktop
webview
framework
native
moon add vectie/lepusa@0.1.6
Download zip
Author
Version
0.1.6
License
Apache-2.0
Repository
Last updated
14 days ago
Downloads
184

Dependencies

README

#Lepusa

Lepusa is a standalone MoonBit desktop application framework.

The core decision is to build a MoonBit-owned, Tauri-shaped framework on top of system WebViews, with an app-authoring style close to Rabbita. Tauri and Lepus are references to learn from, not runtime layers that app authors must carry.

Start with:

#Intended Shape

MoonBit app code
  -> Rabbita-style Lepusa app syntax
  -> typed command + event IPC
  -> capability-scoped platform plugins
  -> system WebView runtime
  -> platform bundles for macOS, Windows, and Linux

The first implementation slice already owns the public MoonBit foundation:

  • Rabbita-style cell_with_emit and new(cell) app construction
  • @lepusa/ui HTML helpers plus UiProgram model/update/view state flow for compact MoonBit-authored desktop views
  • WindowConfig, Source, Plugin, Capability, Cmd, Event, and typed IPC request/response contracts
  • ProjectManifest validation plus LaunchPlan, RuntimePlan, and BundlePlan generation as the boundaries native runtime and platform bundler code will consume next
  • @lepusa/project parsing for standalone lepusa.json app manifests, including official plugin expansion and capability-scoped command routing
  • @lepusa/bundle native bundle materialization from BundlePlan without coupling build tools to CLI internals
  • @lepusa/scaffold app and plugin skeleton generation for ecosystem tooling without shelling through lepusa init
  • @lepusa/desktop app-facing official plugin kit that keeps plugin declarations, capability grants, and runtime command handlers in sync
  • @lepusa/runtime host/session snapshots that native WebView backends can consume without reinterpreting app configuration
  • @lepusa/runtime.NativeRuntime as the single native-loop facade over backend bootstrap, asset protocol responses, IPC dispatch, and lifecycle steps
  • @lepusa/runtime.NativeOperationExecutor as the shared execution boundary for startup, lifecycle, and bridge-drain operations that platform loops must map to WebView evaluation, navigation, effects, and service work

The common authoring path is intentionally small:

///|
fn main {
  let (emit, cell) = @lepusa.cell_with_emit(model=init_model(), update~, view=(
    emit,
    model,
  ) => render_app(emit, model))
  let app = @lepusa.new(cell)
    .with_startup(load_initial_state(emit))
    .on_shutdown(persist_state(emit))
    .window(title="Hello Lepusa", width=1000, height=720)
  match app.launch_plan() {
    Ok(plan) => boot_native_runtime(plan)
    Err(problems) => fail_fast(problems)
  }
}

The optional @lepusa/ui package supplies concise view helpers while still returning root @lepusa.Html values:

///|
fn render_app(emit, model) {
  @ui.main_([
    @ui.h1([@ui.text("Counter")]),
    @ui.p([@ui.text("Count: \{model.count}")], attrs=[@ui.class_name("metric")]),
    @ui.p([@ui.text("Starting")], attrs=[@ui.id("status")]),
    @ui.button("Increment", attrs=[@ui.on_click("counter.increment")]),
    @ui.text_listener("ready", "#status"),
  ])
}

For backend and packaging work, the app model can be lowered without pulling in product-specific code:

///|
let runtime = app.runtime_plan(config=@lepusa.RuntimeConfig::system_webview())

///|
let bundle = @lepusa.BundleConfig::new(
  @lepusa.AppMetadata::new(
    identifier="dev.example.app",
    product_name="Example App",
    version="0.1.0",
  ),
)

For official desktop APIs, @lepusa/desktop.DesktopProject wires the framework parts together:

///|
let project = @desktop.DesktopProject::new(metadata, root)
  .window(title="Desk", source=@lepusa.Source::html("<main></main>"))
  .with_sync_plugins()

///|
let host = project.runtime_host().unwrap()

///|
let bundle = project.bundle_plan(target=@lepusa.MacOS).unwrap()

For programmatic project configuration, use ProjectManifest:

///|
let manifest = @lepusa.ProjectManifest::new(metadata)
  .with_window(
    @lepusa.WindowConfig::new(source=@lepusa.Source::packaged("dist")),
  )
  .with_plugin(@lepusa.Plugin::new("core").command_sync("invoke"))
  .with_capability(
    @lepusa.Capability::new("main").window("main").command("core.invoke"),
  )

///|
let runtime = manifest.runtime_plan(root)

///|
let bundle = manifest.bundle_plan(root, target=@lepusa.MacOS)

For file-backed apps, @lepusa/project owns reusable lepusa.json loading and parsing:

///|
match @project.ProjectConfig::load("lepusa.json") {
  Ok(project) =>
    project.manifest().runtime_plan(project.root())
  Err(problems) =>
    fail_fast(problems)
}

#CLI

The native CLI is intentionally small while the runtime backend is being built:

moon run cmd/main --target native -- doctor linux
moon run cmd/main --target native -- plan
moon run cmd/main --target native -- manifest
moon run cmd/main --target native -- native-plan macos
moon run cmd/main --target native -- launch-session linux
moon run cmd/main --target native -- launch-session linux --async-bridge
moon run cmd/main --target native -- run linux --project examples/gateway/lepusa.json
moon run cmd/main --target native -- run linux --json --project examples/gateway/lepusa.json
moon run cmd/main --target native -- verify linux --project examples/static/lepusa.json
moon run cmd/main --target native -- verify linux --strict --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- run macos --launch --project examples/static/lepusa.json
moon run cmd/main --target native -- bridge
moon run cmd/main --target native -- dev
moon run cmd/main --target native -- init _build/lepusa-app
moon run cmd/main --target native -- init _build/lepusa-app --workspace /Users/kq/Workspace/lepusa
moon run cmd/main --target native -- plan --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- manifest --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- native-plan linux --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- launch-session linux --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- dev --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- asset lepusa://rabbita/main/index.html --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- lifecycle app-will-exit --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- bridge-task main log.write '{"message":"ready"}' --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- bridge-handoff main log.write '{"message":"ready"}' --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- bridge-complete main fs.readText '{"scope":"data","path":"note.txt"}' --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- bridge-dispatch main log.write '{"message":"ready"}' --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- bridge-loop main fs.readText '{"scope":"data","path":"note.txt"}' --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- bridge-drain main fs.readText '{"scope":"data","path":"note.txt"}' --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- plugin new file-dialog _build/lepusa-plugin-file-dialog
moon run cmd/main --target native -- plugin new file-dialog _build/lepusa-plugin-file-dialog --workspace /Users/kq/Workspace/lepusa
moon run cmd/main --target native -- bundle-plan macos
moon run cmd/main --target native -- bundle-plan macos --json
moon run cmd/main --target native -- bundle-write linux _build/lepusa-bundle --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- bundle-inspect _build/lepusa-bundle/lepusa-app/lepusa/distribution.json
moon run cmd/main --target native -- bundle-release-plan _build/lepusa-bundle/lepusa-app/lepusa/distribution.json --json
moon run cmd/main --target native -- bundle-release-write _build/lepusa-bundle/lepusa-app/lepusa/distribution.json _build/lepusa-release
moon run cmd/main --target native -- bundle-package-plan _build/lepusa-bundle/lepusa-app/lepusa/distribution.json --json
moon run cmd/main --target native -- bundle-package-write _build/lepusa-bundle/lepusa-app/lepusa/distribution.json _build/lepusa-package
moon run cmd/main --target native -- bundle-install-smoke-plan _build/lepusa-bundle/lepusa-app/lepusa/distribution.json /Applications
moon run cmd/main --target native -- bundle-install-smoke-write _build/lepusa-bundle/lepusa-app/lepusa/distribution.json _build/lepusa-install-smoke /Applications
moon run cmd/main --target native -- publish-plan linux --project examples/static/lepusa.json
moon run cmd/main --target native -- publish-plan linux --project examples/static/lepusa.json --json
moon run cmd/runtime --target native -- --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- run --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- launch --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- bootstrap --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- launch-session --async-bridge --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- asset lepusa://packaged/main/index.html --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- lifecycle app-started --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- bridge-task main log.write '{"message":"ready"}' --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- bridge-handoff main log.write '{"message":"ready"}' --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- bridge-complete main fs.readText '{"scope":"data","path":"note.txt"}' --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- bridge-dispatch main log.write '{"message":"ready"}' --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- bridge-loop main fs.readText '{"scope":"data","path":"note.txt"}' --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- bridge-drain main fs.readText '{"scope":"data","path":"note.txt"}' --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/runtime --target native -- invoke main log.write '{"message":"ready"}' --manifest _build/lepusa-bundle/lepusa-app/lepusa/runtime.json
moon run cmd/main --target native -- build macos _build/lepusa-build --project _build/lepusa-app/lepusa.json
moon run cmd/main --target native -- bundle windows _build/lepusa-bundle-win

macOS disk-image packaging stages the application with an Applications shortcut, giving users the familiar drag-to-Applications installation flow.

These commands exercise the public planning contracts and give the native runtime and bundler work concrete outputs to consume.

lepusa doctor [macos|windows|linux] checks the portable runtime and bundle plans, reports the selected target's native launch gate and signing prerequisites, and reports host WebView availability for the platform backend descriptors: WKWebView on macOS, WebView2 on Windows, and WebKitGTK on Linux. It also runs the materialization-independent bundle contract checks over the generated runtime and distribution manifests, including packaged bridge dispatch smoke for safe built-in sync routes. It also prints typed backend preflight lines that separate host dependency availability, WebView creation loops, sync bridge response evaluation, and async bridge drain support. The underlying NativeBackendPreflight JSON classifies the active blocker as dependency, webview-creation, or none, and carries separate dependency, WebView creation, sync bridge evaluation, and async bridge drain problem fields for tooling. Passing --json emits one machine-readable health report with runtime, manifest, handler coverage, bundle, bundle contract, native launch, signing, and platform preflight sections. Passing --strict turns the aggregate health report into a CI gate: missing handlers, release-readiness issues, or selected-target native launch blockers make doctor exit with failure.

lepusa plan includes resolved WebView load URLs, so backend work can consume RuntimePlan::windows() directly.

lepusa launch-session and lepusa-runtime launch-session emit a target-aware native-loop readiness envelope. Its session field carries the WebViews, protocol assets, lifecycle actions, service supervision, bridge scheduling, the async bridge executor descriptor, and the bridgeLoop adapter, delivery, and drain contract. The envelope also records requestedBridgeMode, effectiveBridgeMode, and bridgeModeGranted, then reports backend capability through launchCapability, backendPreflight, targetCanLaunch, and targetLaunchBlocker. Passing --async-bridge records an async-capable request; platforms with packetized drain support keep that effective mode, report bridgeModeGranted: true, and expose a drainStrategy of event-loop. The target launch blocker includes the backend's concrete asyncBridgeDrainMessage, so dependency or creation-loop failures stay separate from bridge scheduler readiness. Async-capable sessions advertise a packetized event-loop drain: the native message handler may queue deferred work synchronously, then the host loop asks MoonBit for a lepusa-ops-v3 drain packet and evaluates completion scripts after leaving the WebView callback. Platform runners now lower the first WebView from that session through NativeWebViewLaunchContext, which keeps the native byte packet together with the scheduler, async executor, and bridgeLoop contract the backend must honor. Launch capability also carries the backend's maximum live WebView count. Current macOS, Linux, and Windows native loops advertise no hard cap and consume open-window packets through the same labeled WebView creation boundary used for static multi-window startup and later dynamic windows.

Generated bridges only expose command routes granted to the current window by capabilities. RuntimePlan::command_routes() still reports all declared plugin routes for metadata and bundling. Capability grants can also name origins and platforms; platform-scoped commands are authorized against RuntimeConfig.platform and appear in runtime manifests for native diagnostics.

Lifecycle hooks lower to the same backend action model as startup commands, so platform backends can handle shutdown and window-close events without reading application construction state.

When a window omits source, App lowers the root Cell into a generated Rabbita-style HTML document served from the runtime manifest as a virtual file.

@lepusa/scaffold.write_app writes a standalone MoonBit project skeleton with a versioned vectie/lepusa module dependency. It is intentionally small: moon.mod, lepusa.json, src/moon.pkg, src/main.mbt, and README.mbt.md. The generated src/main.mbt starts with the current @lepusa/ui.UiProgram model/update/view flow and wraps it in @lepusa/desktop.DesktopProject, so custom UI handlers, official desktop plugins, capabilities, runtime hosts, and bundle plans are derived from one project boundary. It uses the @lepusa/desktop sync-safe official plugin profile by default, so the generated MoonBit app stays launchable on native loops that do not yet support deferred async bridge scheduling. write_app_with_workspace also writes a moon.work file pointing at a local Lepusa checkout, which lets new apps compile against this repository before the framework is published to the MoonBit registry. lepusa init is the CLI wrapper over that package:

moon run cmd/main --target native -- init _build/lepusa-app --workspace /Users/kq/Workspace/lepusa

lepusa.json is the app-neutral project boundary. It describes metadata, runtime backend, windows, plugin command routes, command permission requirements, capability grants, bundle icon resources, and bundle signing prerequisites. Native CLI commands consume the nearest lepusa.json from the current directory, or a file passed with --project. The reusable parser lives in @lepusa/project, so tools can consume the same project contract without depending on the CLI binary. File paths in lepusa.json, including icons, packaged asset roots, local asset roots, and filesystem scopes, are resolved relative to the config file. Official plugins can be declared by name, for example { "name": "autoLaunch" }, { "name": "clipboard" }, { "name": "deepLink" }, { "name": "dialog" }, { "name": "fileDialog" }, { "name": "localhost" }, { "name": "notification" }, { "name": "log" }, { "name": "opener" }, { "name": "process" }, { "name": "serviceDiscovery" }, { "name": "shell" }, { "name": "singleInstance" }, { "name": "store" }, { "name": "tray" }, { "name": "updater" }, { "name": "window" }, { "name": "windowState" }, or { "name": "fs" }; Lepusa expands those declarations to the package's official command contract. Custom plugins can still provide an explicit commands array. Projects can also declare filesystemScopes, named roots that are carried into runtime sessions and native launch manifests for backend enforcement. It also describes runtime behavior through startup and lifecycle commands: effect, emit, navigate, and batch map directly to the portable RuntimeAction model consumed by native backends. When a project declares official log, store, fs, opener, process, localhost, serviceDiscovery, or windowState plugins, the CLI binds their MoonBit-native handlers into the project RuntimeHost without adding moon-suite-specific behavior. fs handlers run through the async command registry and are constrained by named filesystemScopes. process.info, process.cwd, process.env, and process.setEnv are portable handlers; process.exit remains a declared route for backend-owned termination policy.

The examples/ directory contains checked project manifests for the three foundation app shapes: Rabbita-style MoonBit UI, packaged static assets, and a localhost gateway with sidecar/readiness metadata.

@lepusa/scaffold.write_plugin writes a standalone plugin skeleton with plugin metadata, native command registration, and a scoped capability helper. write_plugin_with_workspace mirrors the same local moon.work support for plugin authors. lepusa plugin new is the CLI wrapper over that package:

moon run cmd/main --target native -- plugin new file-dialog _build/lepusa-plugin-file-dialog --workspace /Users/kq/Workspace/lepusa

BundlePlan::runtime_dependencies() and BundlePlan::signing_prerequisites() expose target-specific distribution requirements for macOS, Windows, and Linux. Windows plans explicitly carry both the Microsoft Edge WebView2 Runtime requirement and the WebView2Loader.dll placement expected beside lepusa-runtime.exe, so future installer generation can consume one bundle contract without a wrapper layer.

BundlePlan::resources() exposes planned bundle resource mappings such as the application icon. The generated bundle runtime file includes these mappings under resources, and @lepusa/bundle.write_plan copies them as file data next to generated bundle files without re-reading project configuration. lepusa bundle-write is a thin CLI wrapper over that package.

Projects can also declare portable runtime assets and sidecar executables in lepusa.json. Non-executable entries are placed in the target's shared resource directory; executable entries are placed beside lepusa-runtime, retain executable permissions, and are available to local-service commands on PATH:

{
  "bundleResources": [
    { "source": "public", "path": "public" },
    {
      "source": "_build/native/release/build/cmd/server/server.exe",
      "path": "local-server",
      "executable": true
    }
  ]
}

Generated launchers expose LEPUSA_APP_DIR, LEPUSA_RESOURCE_DIR, and LEPUSA_APP_DATA_DIR, prepend the bundled executable directory to PATH, and launch from the shared resource directory. This keeps application resources read-only while giving sidecars a stable per-user data location.

Projects can also declare portable runtime assets and sidecar executables in lepusa.json. Non-executable entries are placed in the target's shared resource directory; executable entries are placed beside lepusa-runtime, retain executable permissions, and are available to local-service commands on PATH:

{
  "bundleResources": [
    { "source": "public", "path": "public" },
    {
      "source": "_build/native/release/build/cmd/server/server.exe",
      "path": "local-server",
      "executable": true
    }
  ]
}

Generated launchers expose LEPUSA_APP_DIR, LEPUSA_RESOURCE_DIR, and LEPUSA_APP_DATA_DIR, prepend the bundled executable directory to PATH, and launch from the shared resource directory. This keeps application resources read-only while giving sidecars a stable per-user data location.

@lepusa/plugins/log is the first official plugin package. It declares log.write, provides scoped capability helpers, and can register a command handler backed by an in-memory LogBuffer:

///|
let buffer = @log.LogBuffer::new()

///|
let registry = @log.registry(buffer~)

///|
let app = @lepusa.new(root)
  .with_plugin(@log.plugin())
  .with_capability(@log.capability_for_window("main"))

@lepusa/plugins/store follows the same shape for scoped key-value state. It declares store.get, store.set, store.delete, store.clear, and store.keys, backed by a MoonBit Store.

@lepusa/plugins/fs defines the official filesystem command contract and scoped path policy. It declares async routes such as fs.readText, fs.writeText, fs.list, and fs.metadata, plus split read/write capability helpers. The package validates named scopes and relative paths and provides MoonBit handlers for scoped text, bytes, list, metadata, delete, exists, and directory creation operations. Core FileSystemScope values carry named roots through ProjectManifest, RuntimePlan, RuntimeSession, and RuntimeLaunchManifest.

@lepusa/plugins/file_dialog defines file picker routes such as fileDialog.openFile and fileDialog.saveFile, plus scoped default-directory policy that points dialogs at declared filesystem scopes without widening core filesystem access. Its portable registry validates picker payloads and returns delegated open/save contracts, while native_registry opens host pickers through macOS osascript, Linux zenity, or Windows PowerShell/WinForms with the same MoonBit-side validation and scope resolution.

@lepusa/plugins/localhost defines local service lifecycle routes such as localhost.status, localhost.start, localhost.stop, and localhost.waitUntilReady, plus service metadata policy. LocalService and LocalServiceSupervisorPlan provide the shared start, readiness, and shutdown handoff. Its portable registry reports configured services and delegated lifecycle actions; native backends own process execution and HTTP probing.

@lepusa/plugins/deep_link defines app URL scheme routes such as deepLink.getInitialUrls, deepLink.onOpenUrl, and deepLink.openUrl, plus scheme/host policy metadata. Its portable sync registry reports initial URLs, records delegated registration/open requests, and validates scheme/host policy; native backends own OS registration and dispatch.

@lepusa/plugins/single_instance defines app lock and launch handoff routes such as singleInstance.acquire, singleInstance.focus, and singleInstance.onSecondLaunch, plus instance-key policy metadata. Its portable sync registry tracks primary/secondary launch state and focus requests; native backends own cross-process locking and platform window activation.

@lepusa/plugins/tray defines system tray routes such as tray.setIcon, tray.setMenu, tray.setVisible, and tray.onMenuItemClick, plus menu item policy metadata. Its portable registry validates and tracks icon, tooltip, menu, visibility, and destroy state through sync handlers, then delegates status icon creation and OS menu behavior to native backends.

@lepusa/plugins/window defines window routes such as window.open, window.close, window.focus, window.minimize, window.maximize, window.setTitle, window.setSize, and window.setFullscreen. Its portable registry validates dynamic open payloads and records sync control operations for the target window; native backends own the actual WebView/window-manager calls.

@lepusa/plugins/auto_launch defines launch-at-login routes such as autoLaunch.status, autoLaunch.enable, autoLaunch.disable, and autoLaunch.setEnabled, plus startup registration policy metadata. Its portable sync registry validates startup metadata and tracks desired enablement state. Its native registry writes macOS LaunchAgents, Linux autostart desktop entries, or Windows HKCU Run values when the runtime supplies an executable path.

@lepusa/plugins/window_state defines window persistence routes such as windowState.save, windowState.restore, and windowState.clear, plus window-label policy metadata. The portable registry stores state in the current runtime process for windowState.save/set, windowState.restore/get, and windowState.clear; WindowStateFileStore gives native runtimes a durable file-backed registry once platform loops capture geometry and visibility.

@lepusa/plugins/updater defines update lifecycle routes such as updater.check, updater.download, updater.install, and updater.downloadAndInstall, plus feed/channel policy metadata. Its portable registry validates update policy and tracks delegated check, download, install, and restart lifecycle state; native backends own feed retrieval, signature verification, installation, and restart.

@lepusa/plugins/service_discovery defines service lookup and status routes such as serviceDiscovery.list, serviceDiscovery.resolve, serviceDiscovery.status, and serviceDiscovery.onServiceChanged, plus endpoint policy metadata. Its portable registry lists, resolves, and reports configured endpoints, including endpoints derived from local services; native backends own resolver integration, health checks, and change watching.

@lepusa/plugins/dialog defines platform-neutral dialog routes: dialog.message, dialog.confirm, and dialog.prompt. Its portable registry validates payloads and returns deterministic runtime-owned responses; native backends own the actual OS dialog implementation.

@lepusa/plugins/clipboard provides sync text clipboard handlers backed by native system clipboard stubs for desktop runtimes, plus an in-process ClipboardStore for deterministic tests. @lepusa/plugins/notification provides sync permission and show handlers backed by macOS/Linux native delivery when available, plus an in-process NotificationCenter for deterministic tests and fallback hosts.

@lepusa/plugins/opener declares platform-neutral URL and path opener routes: opener.openUrl, opener.openPath, and opener.revealPath. Its portable registry validates payloads and calls the platform opener through native stubs (open, xdg-open, or ShellExecute/explorer), returning launch status without holding product-specific state.

@lepusa/plugins/shell declares explicit shell execution and process lifecycle routes. Its portable registry validates commands against an optional allow-list and tracks delegated spawned process state, stdin writes, and kill requests; native backends own actual OS execution and platform-specific restrictions.

@lepusa/plugins/process declares process metadata, environment, and control routes behind split process.info, process.environment, and process.control permissions. The portable sync registry implements process metadata, current-directory, and environment handlers; native backends own process termination policy.

@lepusa/plugins/catalog centralizes official plugin lookup for framework tooling. Project parsing uses it to expand name-only official plugin declarations and bind MoonBit handlers where they exist, including scoped async filesystem handlers and portable sync process, localhost, service-discovery, deep-link, single-instance, tray, auto-launch, window, and window-state handlers.

lepusa manifest emits the portable native-runner JSON from RuntimeHost::launch_manifest(): WebView boot data, bridge hook names, document-start scripts, protocol mappings, inline virtual files with MIME types, declared command routes, and registered native routes.

lepusa native-plan [macos|windows|linux] emits the selected backend's NativeRunnerPlan::bootstrap_json(), including the portable runtime manifest, per-window WebView specs, startup operations, and prelowered lifecycle operations that a platform runner needs. The bootstrap also includes bridgeScheduler, the shared sync-only/async-capable launch policy derived from registered bridge routes.

lepusa launch-session [macos|windows|linux] prepares the selected backend and emits a readiness envelope around the same canonical NativeLaunchSession shape used by packaged runtime manifests: concrete WebView launch plans, executable operations, bridge scheduler policy, async bridge executor metadata, service supervisor plan, requested versus effective bridge mode, and target launch capability.

lepusa run [macos|windows|linux] --project lepusa.json lowers the same NativeRunnerPlan and prints a compact runner smoke summary: selected backend, WebView engine, first URL, bridge URL, local services, startup operations, and lifecycle steps. The summary also includes target-can-launch and a blocker message when the selected target is known to be missing a native WebView launch loop. Passing --json emits the same canonical RunReport used by packaged runtime reports. It is intentionally a no-window command unless --launch is passed.

lepusa verify [macos|windows|linux] --project lepusa.json runs the no-write foundation proof for an app: runtime plan, dev plan, launch manifest, bridge asset, nonblank initial WebView content for resolvable assets, handler coverage, native launch session, bundle runtime contract, and release-readiness metadata plus package-readiness blockers. Add --strict when the command should act as a release gate: missing concrete handlers, known target launch blockers, bundle release-readiness issues, and package-readiness blockers become failures instead of warnings. This keeps framework-development proofs useful while still giving CI a direct answer for "can this target ship?" Passing --json emits the selected target, strict mode, final pass/fail, and the canonical verifier lines plus structured release-readiness data as a machine-readable report, including the generated package plan readiness. The native-session line reports scheduler readiness separately from selected target launch readiness, so Windows and async-bridge blockers are visible even outside strict mode. lepusa doctor prints the same target launch-gate blocker as a warning so local diagnostics stay non-fatal while still showing whether the selected target can launch natively today. lepusa publish-plan [macos|windows|linux] --project lepusa.json is the third-party project release spine. It derives the strict verification command, bundle output root, distribution manifest path, release handoff root, package handoff root, package script command, and release/package readiness from the same lepusa.json and bundle distribution contract. Passing --json emits the same command list and readiness fields for CI jobs or external release tools.

@lepusa/runtime turns a RuntimePlan into a RuntimeSession: resolved window frames, protocol mappings, virtual files, generated bridge source, and command dispatch through the declared capabilities. NativeRunnerPlan keeps full per-window RuntimeWebViewSpec records alongside the portable launch manifest so backend implementations can create windows without re-deriving bridge hooks or initialization scripts. It also exposes lifecycleOperations from the current RuntimeSession; each step carries the operations and resulting session snapshot so native backends can resolve assets after shutdown or window-event navigation without retaining app construction state.

RuntimeSession::resolve_window_asset(window_label, url) is the pure custom-protocol boundary for native WebViews. It resolves lepusa://runtime/bridge.js, inline/Rabbita virtual files, safe local asset paths, and packaged app assets without doing platform file IO, while denying cross-window asset requests. RuntimeSession::resolve_asset_json(url) and RuntimeHost::resolve_asset_json(url) expose the same boundary as a stable JSON envelope for native protocol handlers: virtual content, local file paths, packaged file paths, or a structured error. Use their resolve_window_asset_json variants from platform handlers; the unscoped forms are for CLI and manifest inspection. lepusa asset <url> --project lepusa.json prints that envelope directly, so desktop projects can smoke-test the custom protocol without starting a WebView.

RuntimeHost::dispatch_json(input) is the native hook boundary for WebView IPC. It decodes the bridge request object, verifies the route is declared by the runtime plan, checks capabilities through the command registry, and returns the JSON response shape expected by window.lepusa. RuntimeHost::dispatch_json_async(input) is the native loop path for async plugin handlers; sync handlers still run through the same permission checks. RuntimeHost::bridge_dispatch_task(message) and NativeRuntime::bridge_dispatch_task(message) wrap the same bridge request as a target-window response task with route metadata and a sync/async mode, so native loops can immediately answer sync commands or schedule async commands and later evaluate the generated response script. The task JSON includes the original bridge message and requiresAsyncDispatch flag so native handlers do not need to re-derive scheduling metadata. Bundled manifests expose the same contract through BundledRuntime::bridge_dispatch_task(message). RuntimeHost::bridge_handoff(message) and NativeRuntime::bridge_handoff(message) combine that task with an immediate dispatch result for sync routes, or a deferred handoff for async routes. This is the narrow callback shape native event loops use before they schedule async work. NativeBridgeHandoff::complete_deferred(runtime) turns that deferred task into a NativeBridgeCompletion, preserving the original task metadata together with the response JSON and JavaScript callback script the platform loop should evaluate. Immediate handoffs intentionally reject deferred completion so backend code cannot accidentally run a sync command twice. NativeBridgeWorkQueue is the shared FIFO queue for platform loops: handoff_callback(runtime) returns immediate scripts for sync routes, enqueues deferred async routes, and lets the loop drain completions later before evaluating each callback script in the target WebView. Packaged runtimes expose the same shape as BundledBridgeWorkQueue. handoff_packet_callback is the native C/WebView ABI for that handoff: it returns status\n<window>\n<body-byte-length>\n<body>\n<operation-packet> where the final section is the versioned lepusa-ops-v3 length-prefixed native operation packet. Immediate packets carry the callback script plus executable operations, deferred packets carry the queued task count, and error packets carry a diagnostic body. The v3 operation records include dynamic open-window boot metadata: load URL, title, size, resizable flag, bridge source, native hook, asset protocol, and packetized evaluate-script payloads. macOS, Linux, and Windows parse this packet, evaluate immediate scripts in the target WebView, and consume follow-up operations without JSON-scanning escaped payloads. NativeBridgeLoopAdapter and BundledBridgeLoopAdapter bundle the runtime, queue, native message callback, pending-state diagnostics, and drain operation into the object platform event loops should keep beside each WebView host. Their async receive_message method accepts one UTF-8 WebView bridge message and returns a loop result: immediate scripts for sync routes, drained completion scripts for async routes, and JSON diagnostics for backend tests. NativeBridgeScheduler and NativeBridgeLoopContract now surface drainStrategy, so target readiness distinguishes sync-only loops from native loops that can schedule the queued async drain on their event loop. NativeBridgeLoopEvaluationPlan lowers those scripts into target-window evaluate-script operations, giving every platform runner the same operation shape for its drain/evaluate step. receive_window_message returns a NativeBridgeLoopDelivery / BundledBridgeLoopDelivery, pairing the raw loop result with that executable plan for the target window. drain_window returns the same delivery shape for async tasks previously captured by the message-handler handoff callback, which is the native loop path for post-callback WebView evaluation. The callback bundles also expose drain_window_scripts, a compact UTF-8 JavaScript payload for native loops that only need to evaluate the completed callback scripts, drain_window_packet, a UTF-8 handoff packet carrying the same typed evaluate-script operations, plus drain_window_operation, a drain-bridge-window executable operation naming the window and packet-drain callback a platform loop must schedule. Deferred handoff packets carry that drain-bridge-window operation immediately, so native loops can enqueue the event-loop wakeup from the same packet they return to the WebView callback. The native C loops parse and retain those drain requests, then issue a lepusa-drain-v1 request through the same packet handoff callback and execute the returned lepusa-ops-v3 drain operations. NativeOperationExecutor is the MoonBit-side runner contract for that delivery: platform packages provide handlers for drain-bridge-window, evaluate-script, navigate-window, run-effect, and service operations, then receive a typed execution report instead of parsing operation JSON. RuntimeHost::dispatch_bridge_message(message) and BundledRuntime::dispatch_bridge_message(message) execute that captured bridge message and return the response JSON plus the callback script a native WebView loop evaluates after sync or async command completion.

lepusa bridge-task <window> <plugin.command> [payload] --project lepusa.json prints that source-project scheduling task without starting a WebView. lepusa bridge-handoff <window> <plugin.command> [payload] --project lepusa.json prints the immediate-or-deferred native callback handoff for that bridge message. lepusa bridge-complete <window> <plugin.command> [payload] --project lepusa.json executes the deferred-completion path and prints the completion envelope used by native event loops after async work finishes. lepusa bridge-dispatch <window> <plugin.command> [payload] --project lepusa.json executes the same bridge message and prints the native callback envelope without starting a WebView. lepusa bridge-loop <window> <plugin.command> [payload] --project lepusa.json feeds one source-project WebView message through the bridge-loop adapter and prints the immediate script, drained async completions, and evaluation scripts plus the native executable evaluation plan a platform loop should run. lepusa bridge-drain <window> <plugin.command> [payload] --project lepusa.json simulates the split native loop: the message-handler handoff callback runs first, then pending async work drains into a target-window delivery envelope. lepusa invoke <window> <plugin.command> [payload] --project lepusa.json executes the same host dispatch path from the CLI. It is a native smoke-test tool for project configuration, official plugin registration, and capability grants. lepusa lifecycle <event> [window] --project lepusa.json prints the runtime step JSON for startup, shutdown, and window lifecycle events without starting a native window loop.

The generated bridge also exposes window.lepusa.listen(name, handler) and installs globalThis.__lepusaDispatchEvent(event) for native-to-frontend events.

RuntimePlan::actions(cmd) lowers Cmd::emit, Cmd::navigate, and Cmd::effect into backend-executable RuntimeAction values. Startup actions are included in RuntimePlan::launch_manifest().

RuntimeHost::webviews() produces per-window boot specs for native backends: window frame data, load URL, asset protocol, native hook name, and document start scripts.

lepusa bridge emits the JavaScript bridge that frontends load as window.lepusa, including invoke(route, payload), can(route), command(route), and a frozen commands route tree such as lepusa.commands.core.invoke(payload). Direct route namespaces such as lepusa.core.invoke(payload) are also installed when they do not collide with core bridge methods.

lepusa dev lowers the current project into a runtime development plan: resolved WebViews, asset protocol, capability grants, capability-filtered routes, runtime session, startup operations, lifecycle steps, and bridge scheduling routes. The plan now includes a devSession object that classifies each WebView as runtime protocol assets, supervised localhost, external URL, or custom URL, records whether the runner owns window reload or an external frontend server owns reload, and links supervised frontend services without re-reading project configuration. It also prints the concrete inspect, manifest, verify, run, and bundle commands for each desktop target, so a generated or file-backed app has an immediate local development loop without extra project-specific scripts. lepusa dev --json emits the same plan plus reusable command templates as a structured artifact for native runners and external tooling. This is the stable boundary the platform-specific window loops will execute.

RuntimeHost::runner_plan() is the platform-neutral native-loop contract: launch manifest, resolved WebViews, stepped runtime session, and startup operations in one object. Platform packages map this plan to WKWebView, WebView2, or WebKitGTK without rebuilding app state. RuntimeRunnerPlan::lifecycle_step(event) returns the same operation/session shape that lepusa lifecycle prints. RuntimeSession::open_window(window) resolves a new WindowConfig into session-owned protocol mappings, virtual files, sidecar services, and a typed open-window operation containing the WebView spec and initialization scripts. request_window_close(label) and close_window(label) keep close-request lifecycle actions separate from final destruction, and final close removes the window's runtime assets/listeners before emitting a typed close-window operation.

@lepusa/runtime also exposes NativeBackend and NativeRuntime, the shared lowering boundary for platform packages. NativeRuntime binds a backend and host once, then gives platform loops bootstrap JSON, asset JSON, dispatch JSON, service supervisor plans/reports/executors, and lifecycle step JSON without making each backend rebuild those paths. @lepusa.RunReport is the shared launch summary returned by source and packaged runtime adapters, so CLI output and future native loops use one status vocabulary for prepared, launched, failed, and unsupported runs. It also carries target launch readiness separately from run status, so tooling can distinguish a valid prepared plan from a target whose WebView loop is not implemented yet. The same report now carries executable, executed, skipped, and failed operation counts plus the first execution failure, giving CI and native-loop smoke tests a single place to compare planned startup work with what the platform executor can actually handle. Native runner plans also report bridge sync and async route sets, giving platform loops an explicit scheduling contract before they open a WebView. They also expose executable operation views for frontend event scripts and window navigations, so lifecycle/startup reporting uses typed operations before the backend crosses into C. Prepared source and packaged run plans append startup frontend event scripts to the matching WebView initialization script, so launchers consume the same operation boundary they report. NativeOperationExecutor executes those operation arrays through platform handlers and reports executed, skipped, and failed outcomes, giving WebView loops one reusable path for startup, lifecycle, and bridge-drain work. It now includes dynamic open-window and close-window handlers so platform packages can wire multi-window lifecycle without parsing runtime JSON. Capability-approved window.* bridge dispatches also lower their plugin response into a window-control executable operation, so native loops can apply window actions without parsing JavaScript response callbacks. Approved source or packaged window.open and window.close dispatches additionally emit the runtime-owned open-window and close-window lifecycle operations, keeping the dynamic window boundary visible before platform loops perform the concrete frame work. Source RuntimeHost instances retain the updated runtime session after those bridge operations, so later asset-protocol requests can resolve dynamic window virtual files instead of falling back to the original static plan. Capability-approved app.*, menu.*, and tray.* bridge dispatches lower successful plugin responses into a typed desktop-shell executable operation. This gives platform menu, tray, dock, and app-shell implementations one stable native-operation contract while MoonBit keeps permission checks and payload validation at the official plugin boundary. The macOS, Linux, and Windows loops consume those records from bridge packets; app show/hide/setTheme/exit/restart are applied in the native loop, restart relaunches the current command line before closing the current window set, macOS also applies app dock visibility, macOS/Linux/Windows apply app and window menu bars plus tray operations for icon, tooltip, menu, menu popup, visibility, and destroy. Platform operation reports now mark supported app shell, macOS/Linux/Windows app-menu/window-menu and tray operations as executed, including macOS/Linux/Windows menu accelerator rendering for supported shortcut strings and macOS/Linux/Windows menu and tray item click dispatch to menu.onItemClick and tray.onMenuItemClick. The macOS WKWebView, Linux WebKitGTK, and Windows WebView2 loops consume the sync window action set directly from the bridge handoff packet: title, size, position, fullscreen, show, hide, focus, minimize, maximize, unmaximize, and close. They also consume typed close-window records by closing the live native frame once, even when the same handoff also carries the plugin's window-control close response. macOS, Linux, and Windows consume navigate-window operations from the same handoff packet by loading the target URL in the live WebView after the approved MoonBit dispatch completes. The macOS, Linux, and Windows loops now consume dynamic open-window records by creating labeled WKWebView/WebKitGTK/WebView2 windows with the carried bridge source, native hook, asset protocol, URL, title, size, and resizable flag. Source and bundled runners pass URL-routed asset resolver callbacks into native loops, so dynamic WebViews can resolve assets for their own window labels. Platform packages now expose operation_executor() so source and packaged run reports use the backend's actual script-evaluation and window-control support instead of the generic skipped-operation fallback. @lepusa/runtime/macos, @lepusa/runtime/windows, and @lepusa/runtime/linux now provide small backend descriptors and host availability checks for WKWebView, WebView2, and WebKitGTK. Each platform package exposes runtime(host) and detect_runtime(host) helpers that return the same NativeRuntime facade, plus launch_capability() declarations for WebView creation, maximum live WebView count, and async bridge drain support. Platform packages also expose service executor helpers, and native run plans build launch sessions from the selected backend capability before running service startup, opening a WebView, running the app-will-exit lifecycle operation batch after the window loop returns, and then running service shutdown. macOS, Linux, and Windows start tracked sidecar processes, poll HTTP readiness URLs, stop tracked processes through platform-owned native hooks, and install exit/interruption cleanup so supervised sidecars do not outlive the native runner when the app process exits before the normal shutdown step.

Source::localhost(...) supports gateway-style apps that load a local HTTP service and optionally declare the sidecar command plus readiness URL metadata. This data appears in RuntimeSession::local_services() and launch-manifest localServices for native runners to supervise.

lepusa bundle-plan now also validates concrete bundle artifact plans through BundlePlan::files(): platform metadata, manifest-aware launcher stubs, lepusa/runtime.json, and lepusa/distribution.json, with per-window bridge initialization scripts embedded in the runtime manifest. Passing --json emits target metadata, planned resources, runtime dependencies, signing prerequisites and steps, and planned bundle files for CI and native runner tooling. Windows bundle plans now make the app .exe the primary launcher artifact and emit generated native launcher C source plus a .cmd smoke fallback, so package generators do not need application-owned launcher code. The generated distribution manifest records those runtime dependencies beside artifacts, resources, signing data, runtime executable placement, and target metadata without requiring installer tooling to parse the launch manifest. lepusa bundle-inspect <lepusa/distribution.json> parses that manifest and prints either a compact summary or the normalized JSON contract for downstream package generators. lepusa bundle-release-plan <lepusa/distribution.json> lowers the same manifest to ordered release steps for runtime dependency validation, resource staging, signing checks, signing commands, and artifact collection. Each release step carries structured entries with kind, name, path, sourcePath, required, and description fields so release tooling does not need to scrape raw manifest JSON. The release plan also reports required and optional step/item counts plus a ready flag and missingRequiredSteps, giving CI a compact pre-installer release gate before platform-specific signing or installer commands run. @lepusa/bundle.write_release_plan writes that gate as release-plan.json plus a human-readable release-checklist.md, and lepusa bundle-release-write <lepusa/distribution.json> [out-dir] is the CLI wrapper for release jobs and future package generators. BundleDistributionManifest::package_plan() then lowers the same distribution contract into target-aware package commands, expected outputs, and blockers. @lepusa/bundle.write_package_plan writes package-plan.json, package-checklist.md, and a platform package script (package.sh or package.ps1); Windows also receives an installer.nsi script for the setup artifact. lepusa bundle-package-plan and lepusa bundle-package-write are the CLI wrappers. On macOS, the package script signs the staged app before creating the disk image. With a Developer ID and notarization profile configured, it also signs, notarizes, and staples the disk image. The ad-hoc identity - is supported for local integrity testing but does not replace Apple notarization. The bundler prefers a release-mode lepusa-runtime, falls back to the debug runtime, and accepts an explicit LEPUSA_RUNTIME_EXECUTABLE. Packaging now fails instead of producing an unlaunchable app when no runtime is available. BundleDistributionManifest::install_smoke_plan() adds the post-install gate: installed runtime manifest path, required installed files, runtime dependency files when applicable, and lepusa-runtime commands for manifest inspection, dry-run launch planning, async bridge launch-session, bridge asset resolution, and optional GUI launch. @lepusa/bundle.write_install_smoke_plan writes install-smoke-plan.json, install-smoke-checklist.md, and install-smoke.sh/install-smoke.ps1; lepusa bundle-install-smoke-plan and lepusa bundle-install-smoke-write expose the same contract for clean-machine validation. For app authors, lepusa publish-plan [target] --project lepusa.json combines the strict verifier, bundle-write, release handoff, package handoff, final package script invocation, and install-smoke handoff into one target-aware checklist without writing files.

@lepusa/bundle.write_plan materializes those planned files under an output directory. lepusa bundle-write is the CLI wrapper. Project bundles carry registered official plugin routes into lepusa/runtime.json, so packaged runtime data matches the same host path used by lepusa manifest, lepusa dev, and lepusa invoke. Bundle verification records target runtime dependencies too: system WebViews are reported as declared external dependencies, while file-backed dependencies such as Windows WebView2Loader.dll are checked at their planned bundle path. When a file-backed dependency declares a source path, bundle-write copies it before verification; the Windows loader source defaults to _build/native/debug/build/cmd/runtime/WebView2Loader.dll. Projects can override that path in lepusa.json:

{
  "runtimeDependencies": [
    { "name": "WebView2Loader.dll", "source": "vendor/WebView2Loader.dll" }
  ]
}

When the selected bundle target matches an available host runtime backend and the local cmd/runtime native binary exists, bundle-write also embeds a target-named lepusa-runtime executable beside the launcher and verifies it with a runtime-executable check. BundlePlan::runtime_executable_path() exposes that target location before materialization. Cross-target bundles keep a launcher fallback to lepusa-runtime on PATH until Lepusa owns cross-compiled runtime artifacts. bundle-write also verifies that the generated lepusa/runtime.json lowers into a target native launch session against the target launch contract, separate from host dependency availability, and that resolvable initial WebView content is present and nonblank. For built-in sync routes that are allowed by a bundled WebView, it also runs a packaged bridge dispatch smoke check and verifies the response callback script can be produced; custom app routes are skipped until the app supplies generated handlers. It also parses lepusa/distribution.json and checks that installer metadata includes required artifact, dependency, resource, runtime executable, and signing fields. Windows bundles now pass structural native launch-session verification cross-target; missing WebView2Loader.dll or system WebView runtime placement remains a runtime-dependency verification failure. Passing --json emits target, identifier, signing prerequisites, and the reusable BundleWriteResult payload with written files, resources, runtime dependency checks, and verification checks for CI tooling. Generated desktop launcher stubs wrap lepusa-runtime launch --manifest <runtime.json> instead of replacing the launcher process with exec. POSIX wrappers trap INT, TERM, and HUP, wait on the runtime PID, and forward termination to the runtime so CLI smoke runs do not strand supervised local services. The Windows bundle also emits a native C launcher source that starts lepusa-runtime.exe, waits for completion, and returns the runtime exit code. The macOS and Linux runtimes track all native windows and stop tracked local services only after the last WKWebView or WebKitGTK window closes. The Linux package owns WebKitGTK source and packaged-window loops when GTK3 and WebKit2GTK are available, including a package-owned lepusa:// URI scheme callback for MoonBit-resolved runtime, virtual, local, and packaged assets. Windows source and packaged runs use the package-owned WebView2 COM loop when WebView2Loader.dll, its required factory exports, Ole32 COM support, and a discoverable WebView2 Runtime are available, including sync bridge response evaluation, typed dynamic window operations, and a WebView2 resource-request callback that maps https://<protocol>.localhost/... back to MoonBit-resolved runtime, virtual, local, and packaged lepusa://... assets. lepusa-runtime run --manifest <runtime.json> uses a target-aware planning path without opening a window, so bundles have a cheap validation probe. lepusa-runtime bootstrap--manifest <runtime.json> emits the target-aware packaged runtime bootstrap for platform loops: manifest path, bundle root, app metadata, native backend, WebView engine, WebView specs, service supervisor plan, startup operations, lifecycle operations, bridge routes, bridge scheduler policy, and the canonical runtime object that a backend consumes. lepusa-runtime launch-session --manifest <runtime.json> emits the packaged native host readiness envelope: prepared WebView launch plans, executable startup and lifecycle operations, bridge scheduler policy, and service supervisor plan under session, plus target launch capability and blocker fields for packaged native loops. lepusa-runtime --manifest <runtime.json> remains a manifest summary probe and reports the bundled service supervisor requirement plus sidecar start order. lepusa-runtime asset <url> --manifest <runtime.json> resolves the bundled manifest's runtime bridge, virtual files, local roots, and packaged roots using the same JSON envelope shape expected by native protocol handlers. lepusa-runtime lifecycle <event> [window] --manifest <runtime.json> reads the same bundled manifest and returns the local services and portable actions a native loop should process for that lifecycle event. lepusa-runtime bridge-task <window> <plugin.command> [payload] --manifest <runtime.json> returns the MoonBit-owned bridge scheduling task for a packaged command: target window, response hook, original bridge message, route, and sync/async dispatch mode. Native loops can use this as the packaged-manifest probe before wiring platform-specific message handlers. lepusa-runtime bridge-handoff <window> <plugin.command> [payload] --manifest <runtime.json> returns the packaged immediate-or-deferred handoff that native event loops use when deciding whether to answer a WebView callback immediately or schedule async completion. lepusa-runtime bridge-complete <window> <plugin.command> [payload] --manifest <runtime.json> executes the packaged deferred-completion path and returns the same completion envelope native event loops use after async work finishes. lepusa-runtime bridge-dispatch <window> <plugin.command> [payload] --manifest <runtime.json> executes the packaged bridge message and returns the response JSON plus callback script that a native event loop evaluates back into the target WebView. lepusa-runtime bridge-loop <window> <plugin.command> [payload] --manifest <runtime.json> feeds one packaged WebView message through the bundled bridge-loop adapter and returns the immediate script, drained async completions, and evaluation scripts plus the native executable evaluation plan a platform loop should evaluate. lepusa-runtime bridge-drain <window> <plugin.command> [payload] --manifest <runtime.json> simulates the packaged split native loop: handoff callback first, then target-window drain delivery for pending async work. lepusa-runtime invoke <window> <plugin.command> [payload] --manifest <runtime.json> executes a packaged bridge command against the manifest's registered official native handlers. It checks the requested window's allowedRoutes before dispatching and returns the same JSON response shape as project-hosted lepusa invoke. @lepusa/runtime/bundled owns the reusable manifest parser and bootstrap, asset, lifecycle, bridge-task, bridge-loop, and invoke JSON behind those commands, so native platform loops can consume bundled runtime data without depending on CLI internals. BundledRuntime::new(manifest) keeps the native command registry state alive for repeated bridge calls. It also owns bundled bridge message preparation, sync/async dispatch, target-window response-hook lookup, and response-callback scripts, while the manifest helper remains useful for one-shot probes. Bundled native run plans expose startup and lifecycle event scripts plus window navigations as typed runtime values, so packaged app loops can consume the same native-operation boundary as source-project runs. Source and bundled native run plans also serialize to compact handoff artifacts that carry native metadata plus the canonical launch session, while the launch-session CLIs wrap that session with target readiness metadata for tools that need to distinguish prepared plans from launchable platform backends and their host dependency preflight state. NativeBackendPreflight keeps the collapsed problem for human summaries, and adds problemKind, dependencyProblem, webviewCreationProblem, and asyncBridgeDrainProblem so release tooling can distinguish an unavailable system dependency from framework backend work that is still intentionally gated. The macOS runner prepares and injects the generated bridge as a document-start WKUserScript, together with a native hook bootstrap and window.webkit.messageHandlers.__lepusaInvoke dispatch path for sync command responses. Native loops now understand the typed packet format needed to evaluate queued callback scripts, retain deferred drain requests, and request a window-scoped lepusa-ops-v3 drain packet from MoonBit through the existing handoff callback. That launch capability carries an asyncBridgeDrainMessage field, which describes the packetized event-loop drain contract separately from WebView dependency, script evaluation, or creation-loop failures. Launch-session JSON also carries asyncBridgeExecutor, which names NativeRuntime::bridge_async_dispatch_callback and its UTF-8 bridge-message to JavaScript-callback-script byte contract. The same bridgeScheduler field appears in source and bundled bootstrap JSON so platform loops and CLI diagnostics read one launch policy. NativeRuntime.prepare_bridge_message, bridge_dispatch_task, and dispatch_bridge_message own the MoonBit side of that path by resolving the target window, response hook, route scheduling mode, sync/async dispatch, and response-callback script. macOS, Linux, and Windows share the same runtime hook-bootstrap and response-script helpers instead of duplicating bridge callback semantics in each backend. The same runner registers a WKURLSchemeHandler for the Lepusa asset protocol. MoonBit still owns asset resolution; the Objective-C stub only turns the runtime asset packet into WebKit response/data/finish calls. The Linux source-window loop injects the same window.lepusa bridge plus a WebKitGTK message-handler bootstrap, so sync native commands can round-trip through MoonBit in an opened WebKitGTK window. Its WebKitGTK URI-scheme handler also calls back into MoonBit for runtime asset resolution, keeping packaged Linux windows on the same lepusa:// contract as macOS. Source::packaged("dist") also emits an asset resource mapping and lepusa bundle-write copies that directory into lepusa/assets/<window>. The generated bundle runtime manifest rewrites packaged protocol roots to that bundle-relative location, while runtime asset probes return packaged-file envelopes for lepusa://packaged/<window>/... URLs.

#Boundary

Lepusa owns the reusable desktop framework:

  • native window and WebView runtime
  • frontend-to-MoonBit command bridge
  • app capabilities and permissions
  • official platform plugins
  • dev/build/bundle CLI

Consumer projects own product behavior, backend services, schemas, routes, workspaces, dashboards, and domain-specific adapters.

#
AsyncCommandHandler

source
type AsyncCommandHandler = async (String) -> Result[String, String]

#
CommandHandler

source
type CommandHandler = (String) -> Result[String, String]

#
Emit

source
type Emit[Msg] = (Msg) -> Cmd

#
OperationScopeResolver

source
type OperationScopeResolver = (InvokeRequest) -> Result[OperationScope, String]

#
StreamCommandHandler

source
type StreamCommandHandler = (String, StreamSink) -> Result[Unit, String]

#
App

source
pub struct App {
  root : Cell
  windows : Array[WindowConfig]
  plugins : Array[Plugin]
  capabilities : Array[Capability]
  startup : Cmd
  lifecycle_hooks : Array[LifecycleHook]
} derive(Eq, 
Debug)

#
App::launch_plan

source
fn App::launch_plan(self : App) -> Result[LaunchPlan, Array[String]]

#
App::manager

source
fn App::manager(self : App, config? : RuntimeConfig, registry? : CommandRegistry) -> Result[AppManager, Array[String]]

#
App::on_shutdown

source
fn App::on_shutdown(self : App, command : Cmd) -> App

#
App::on_window_close_requested

source
fn App::on_window_close_requested(self : App, label : String, command : Cmd) -> App

#
App::on_window_closed

source
fn App::on_window_closed(self : App, label : String, command : Cmd) -> App

#
App::runtime_plan

source
fn App::runtime_plan(self : App, config? : RuntimeConfig) -> Result[RuntimePlan, Array[String]]

#
App::validate

source
fn App::validate(self : App) -> Array[String]

#
App::window

source
fn App::window(self : App, label? : String, title? : String, width? : Int, height? : Int, resizable? : Bool, title_bar? : TitleBarStyle, source? : Source) -> App

#
App::with_capability

source
fn App::with_capability(self : App, capability : Capability) -> App

#
App::with_lifecycle

source
fn App::with_lifecycle(self : App, event : LifecycleEvent, command : Cmd) -> App

#
App::with_plugin

source
fn App::with_plugin(self : App, plugin : Plugin) -> App

#
App::with_startup

source
fn App::with_startup(self : App, startup : Cmd) -> App

#
App::with_window

source
fn App::with_window(self : App, window : WindowConfig) -> App

#
AppManager

source
pub struct AppManager {
  plan : RuntimePlan
  registry : CommandRegistry
  resources : ResourceTable
  channels : ChannelTable
  events : EventBus
  state : AppStateStore
}

#
AppManager::audit

source
fn AppManager::audit(self : AppManager) -> RuntimeAudit

#
AppManager::cancel_channel

source
fn AppManager::cancel_channel(self : AppManager, id : String) -> Result[ChannelMessage, String]

#
AppManager::capability_count

source
fn AppManager::capability_count(self : AppManager) -> Int

#
AppManager::channel

source
fn AppManager::channel(self : AppManager, id : String) -> Channel?

#
AppManager::channel_count

source
fn AppManager::channel_count(self : AppManager) -> Int

#
AppManager::close_all_resources

source
fn AppManager::close_all_resources(self : AppManager) -> ResourceCleanupReport

#
AppManager::close_resource

source
fn AppManager::close_resource(self : AppManager, id : String) -> Result[ResourceEntry, String]

#
AppManager::close_resource_handle

source
fn AppManager::close_resource_handle(self : AppManager, handle : ResourceHandle) -> Result[ResourceEntry, String]

#
AppManager::command_routes

source
fn AppManager::command_routes(self : AppManager) -> Array[String]

#
AppManager::dispatch

source
fn AppManager::dispatch(self : AppManager, request : InvokeRequest) -> InvokeResponse

#
AppManager::dispatch_async

source
async fn AppManager::dispatch_async(self : AppManager, request : InvokeRequest) -> InvokeResponse

#
AppManager::drain_channel

source
fn AppManager::drain_channel(self : AppManager, id : String) -> Result[Array[ChannelMessage], String]

#
AppManager::emit

source
fn AppManager::emit(self : AppManager, event : Event, target? : EventTarget) -> Result[Array[EventDelivery], Array[String]]

#
AppManager::end_channel

source
fn AppManager::end_channel(self : AppManager, id : String) -> Result[ChannelMessage, String]

#
AppManager::fail_channel

source
fn AppManager::fail_channel(self : AppManager, id : String, message : String) -> Result[ChannelMessage, String]

#
AppManager::invoke_contract_report

source
fn AppManager::invoke_contract_report(self : AppManager) -> InvokeContractReport

#
AppManager::invoke_contracts

source
fn AppManager::invoke_contracts(self : AppManager) -> Array[InvokeContract]

#
AppManager::listen

source
fn AppManager::listen(self : AppManager, name : String, target? : EventTarget, once? : Bool) -> Result[EventListener, Array[String]]

#
AppManager::listener_count

source
fn AppManager::listener_count(self : AppManager) -> Int

#
AppManager::manage_state

source
fn AppManager::manage_state(self : AppManager, key : String, kind? : String, value? : String) -> Result[AppStateEntry, Array[String]]

#
AppManager::new

source
fn AppManager::new(plan : RuntimePlan, registry? : CommandRegistry) -> AppManager

#
AppManager::once

source
fn AppManager::once(self : AppManager, name : String, target? : EventTarget) -> Result[EventListener, Array[String]]

#
AppManager::open_channel

source
fn AppManager::open_channel(self : AppManager, owner? : String, name? : String, metadata? : String) -> Result[Channel, Array[String]]

#
AppManager::open_resource

source
fn AppManager::open_resource(self : AppManager, descriptor : ResourceDescriptor) -> Result[ResourceEntry, Array[String]]

#
AppManager::plan

source
fn AppManager::plan(self : AppManager) -> RuntimePlan

#
AppManager::plugin_count

source
fn AppManager::plugin_count(self : AppManager) -> Int

#
AppManager::registered_routes

source
fn AppManager::registered_routes(self : AppManager) -> Array[String]

#
AppManager::registry

source
fn AppManager::registry(self : AppManager) -> CommandRegistry

#
AppManager::remove_state

source
fn AppManager::remove_state(self : AppManager, key : String) -> Result[AppStateEntry, String]

#
AppManager::resource

source
fn AppManager::resource(self : AppManager, id : String) -> ResourceEntry?

#
AppManager::resource_count

source
fn AppManager::resource_count(self : AppManager) -> Int

#
AppManager::resource_handles

source
fn AppManager::resource_handles(self : AppManager) -> Array[ResourceHandle]

#
AppManager::resource_handles_by_kind

source
fn AppManager::resource_handles_by_kind(self : AppManager, kind : String) -> Array[ResourceHandle]

#
AppManager::resource_handles_by_owner

source
fn AppManager::resource_handles_by_owner(self : AppManager, owner : String) -> Array[ResourceHandle]

#
AppManager::resource_leak_report

source
fn AppManager::resource_leak_report(self : AppManager) -> ResourceLeakReport

#
AppManager::resources

source
fn AppManager::resources(self : AppManager) -> Array[ResourceEntry]

#
AppManager::security_profile

source
fn AppManager::security_profile(self : AppManager) -> SecurityProfile

#
AppManager::send_channel

source
fn AppManager::send_channel(self : AppManager, id : String, payload : String) -> Result[ChannelMessage, String]

#
AppManager::state

source
fn AppManager::state(self : AppManager, key : String) -> AppStateEntry?

#
AppManager::state_count

source
fn AppManager::state_count(self : AppManager) -> Int

#
AppManager::to_json

source
fn AppManager::to_json(self : AppManager) -> String

#
AppManager::unlisten

source
fn AppManager::unlisten(self : AppManager, id : String) -> Result[EventListener, String]

#
AppManager::window_count

source
fn AppManager::window_count(self : AppManager) -> Int

#
AppMetadata

source
pub struct AppMetadata {
  identifier : String
  product_name : String
  version : String
} derive(Eq, 
Debug)

#
AppMetadata::executable_name

source
fn AppMetadata::executable_name(self : AppMetadata) -> String

#
AppMetadata::identifier

source
fn AppMetadata::identifier(self : AppMetadata) -> String

#
AppMetadata::new

source
fn AppMetadata::new(identifier~ : String, product_name~ : String, version~ : String) -> AppMetadata

#
AppMetadata::product_name

source
fn AppMetadata::product_name(self : AppMetadata) -> String

#
AppMetadata::validate

source
fn AppMetadata::validate(self : AppMetadata) -> Array[String]

#
AppMetadata::version

source
fn AppMetadata::version(self : AppMetadata) -> String

#
AppStateEntry

source
pub struct AppStateEntry {
  key : String
  kind : String
  value : String
} derive(Eq, 
Debug)

#
AppStateEntry::key

source
fn AppStateEntry::key(self : AppStateEntry) -> String

#
AppStateEntry::kind

source
fn AppStateEntry::kind(self : AppStateEntry) -> String

#
AppStateEntry::new

source
fn AppStateEntry::new(key~ : String, kind? : String, value? : String) -> AppStateEntry

#
AppStateEntry::to_json

source
fn AppStateEntry::to_json(self : AppStateEntry) -> String

#
AppStateEntry::validate

source
fn AppStateEntry::validate(self : AppStateEntry) -> Array[String]

#
AppStateEntry::value

source
fn AppStateEntry::value(self : AppStateEntry) -> String

#
AppStateStore

source
pub struct AppStateStore {
  entries : Map[String, AppStateEntry]
  order : Array[String]
}

#
AppStateStore::clear

source

#
AppStateStore::contains

source
fn AppStateStore::contains(self : AppStateStore, key : String) -> Bool

#
AppStateStore::count

source
fn AppStateStore::count(self : AppStateStore) -> Int

#
AppStateStore::entries

source

#
AppStateStore::get

source
fn AppStateStore::get(self : AppStateStore, key : String) -> AppStateEntry?

#
AppStateStore::is_empty

source
fn AppStateStore::is_empty(self : AppStateStore) -> Bool

#
AppStateStore::keys

source
fn AppStateStore::keys(self : AppStateStore) -> Array[String]

#
AppStateStore::new

source

#
AppStateStore::put

source
fn AppStateStore::put(self : AppStateStore, entry : AppStateEntry) -> Result[AppStateEntry, Array[String]]

#
AppStateStore::remove

source
fn AppStateStore::remove(self : AppStateStore, key : String) -> Result[AppStateEntry, String]

#
AppStateStore::set

source
fn AppStateStore::set(self : AppStateStore, key : String, kind? : String, value? : String) -> Result[AppStateEntry, Array[String]]

#
AppStateStore::to_json

source
fn AppStateStore::to_json(self : AppStateStore) -> String

#
BackpressureOverflow

source
pub(all) enum BackpressureOverflow {
  RejectNew
  DropOldest
} derive(Eq, 
Debug)

#
BackpressureOverflow::name

source
fn BackpressureOverflow::name(self : BackpressureOverflow) -> String

#
BackpressurePolicy

source
pub struct BackpressurePolicy {
  max_pending : Int
  overflow : BackpressureOverflow
} derive(Eq, 
Debug)

#
BackpressurePolicy::at_capacity

source
fn BackpressurePolicy::at_capacity(self : BackpressurePolicy, pending : Int) -> Bool

#
BackpressurePolicy::bounded

source
fn BackpressurePolicy::bounded(max_pending~ : Int, overflow? : BackpressureOverflow) -> BackpressurePolicy

#
BackpressurePolicy::is_bounded

source
fn BackpressurePolicy::is_bounded(self : BackpressurePolicy) -> Bool

#
BackpressurePolicy::is_unbounded

source
fn BackpressurePolicy::is_unbounded(self : BackpressurePolicy) -> Bool

#
BackpressurePolicy::max_pending

source
fn BackpressurePolicy::max_pending(self : BackpressurePolicy) -> Int

#
BackpressurePolicy::new

source
fn BackpressurePolicy::new(max_pending? : Int, overflow? : BackpressureOverflow) -> BackpressurePolicy

#
BackpressurePolicy::overflow

source

#
BackpressurePolicy::to_json

source
fn BackpressurePolicy::to_json(self : BackpressurePolicy) -> String

#
BackpressurePolicy::unbounded

source

#
BackpressurePolicy::validate

source
fn BackpressurePolicy::validate(self : BackpressurePolicy) -> Array[String]

#
BridgeConfig

source
pub struct BridgeConfig {
  global_name : String
  native_hook : String
  event_dispatch_hook : String
  window_label : String
} derive(Eq, 
Debug)

#
BridgeConfig::new

source
fn BridgeConfig::new(global_name? : String, native_hook? : String, event_dispatch_hook? : String, window_label? : String) -> BridgeConfig

#
BridgeConfig::validate

source
fn BridgeConfig::validate(self : BridgeConfig) -> Array[String]

#
BridgeScript

source
pub struct BridgeScript {
  global_name : String
  native_hook : String
  event_dispatch_hook : String
  window_label : String
  routes : Array[String]
  source : String
} derive(Eq, 
Debug)

#
BridgeScript::event_dispatch_hook

source
fn BridgeScript::event_dispatch_hook(self : BridgeScript) -> String

#
BridgeScript::global_name

source
fn BridgeScript::global_name(self : BridgeScript) -> String

#
BridgeScript::native_hook

source
fn BridgeScript::native_hook(self : BridgeScript) -> String

#
BridgeScript::routes

source
fn BridgeScript::routes(self : BridgeScript) -> Array[String]

#
BridgeScript::source

source
fn BridgeScript::source(self : BridgeScript) -> String

#
BridgeScript::window_label

source
fn BridgeScript::window_label(self : BridgeScript) -> String

#
BundleArtifact

source
pub struct BundleArtifact {
  kind : BundleArtifactKind
  path : String
  description : String
} derive(Eq, 
Debug)

#
BundleArtifact::description

source
fn BundleArtifact::description(self : BundleArtifact) -> String

#
BundleArtifact::kind

source

#
BundleArtifact::new

source
fn BundleArtifact::new(kind~ : BundleArtifactKind, path~ : String, description~ : String) -> BundleArtifact

#
BundleArtifact::path

source
fn BundleArtifact::path(self : BundleArtifact) -> String

#
BundleArtifact::to_json

source
fn BundleArtifact::to_json(self : BundleArtifact) -> String

#
BundleArtifactKind

source
pub(all) enum BundleArtifactKind {
  AppBundleArtifact
  DiskImageArtifact
  ExecutableArtifact
  InstallerArtifact
  PortableDirectoryArtifact
  DesktopEntryArtifact
} derive(Eq, 
Debug)

#
BundleArtifactKind::name

source
fn BundleArtifactKind::name(self : BundleArtifactKind) -> String

#
BundleConfig

source
pub struct BundleConfig {
  metadata : AppMetadata
  target : BundleTarget
  icon_path : String?
  resource_sources : Array[BundleResourceSource]
  runtime_dependency_sources : Array[BundleRuntimeDependencySource]
  signing : SigningConfig
} derive(Eq, 
Debug)

#
BundleConfig::new

source
fn BundleConfig::new(metadata : AppMetadata, target? : BundleTarget, icon_path? : String, resource_sources? : Array[BundleResourceSource], runtime_dependency_sources? : Array[BundleRuntimeDependencySource], signing? : SigningConfig) -> BundleConfig

#
BundleConfig::plan

source
fn BundleConfig::plan(self : BundleConfig, runtime : RuntimePlan, registered_routes? : Array[String]) -> Result[BundlePlan, Array[String]]

#
BundleConfig::validate

source
fn BundleConfig::validate(self : BundleConfig) -> Array[String]

#
BundleFile

source
pub struct BundleFile {
  path : String
  content : String
  executable : Bool
} derive(Eq, 
Debug)

#
BundleFile::content

source
fn BundleFile::content(self : BundleFile) -> String

#
BundleFile::executable

source
fn BundleFile::executable(self : BundleFile) -> Bool

#
BundleFile::new

source
fn BundleFile::new(path~ : String, content~ : String, executable? : Bool) -> BundleFile

#
BundleFile::path

source
fn BundleFile::path(self : BundleFile) -> String

#
BundlePlan

source
pub struct BundlePlan {
  metadata : AppMetadata
  target : BundleTarget
  runtime : RuntimePlan
  registered_routes : Array[String]
  executable_name : String
  bundle_name : String
  icon_path : String?
  resource_sources : Array[BundleResourceSource]
  runtime_dependency_sources : Array[BundleRuntimeDependencySource]
  signing : SigningConfig
} derive(Eq, 
Debug)

#
BundlePlan::artifacts

source
fn BundlePlan::artifacts(self : BundlePlan) -> Array[BundleArtifact]

#
BundlePlan::bundle_name

source
fn BundlePlan::bundle_name(self : BundlePlan) -> String

#
BundlePlan::distribution_manifest_json

source
fn BundlePlan::distribution_manifest_json(self : BundlePlan) -> String

#
BundlePlan::executable_name

source
fn BundlePlan::executable_name(self : BundlePlan) -> String

#
BundlePlan::files

source
fn BundlePlan::files(self : BundlePlan) -> Result[Array[BundleFile], Array[String]]

#
BundlePlan::icon_path

source
fn BundlePlan::icon_path(self : BundlePlan) -> String?

#
BundlePlan::identifier

source
fn BundlePlan::identifier(self : BundlePlan) -> String

#
BundlePlan::registered_routes

source
fn BundlePlan::registered_routes(self : BundlePlan) -> Array[String]

#
BundlePlan::release_readiness

source
fn BundlePlan::release_readiness(self : BundlePlan) -> Result[ReleaseReadinessReport, Array[String]]

#
BundlePlan::resources

source
fn BundlePlan::resources(self : BundlePlan) -> Array[BundleResource]

#
BundlePlan::runtime_dependencies

source
fn BundlePlan::runtime_dependencies(self : BundlePlan) -> Array[BundleRuntimeDependency]

#
BundlePlan::runtime_dependency_sources

source
fn BundlePlan::runtime_dependency_sources(self : BundlePlan) -> Array[BundleRuntimeDependencySource]

#
BundlePlan::runtime_executable_name

source
fn BundlePlan::runtime_executable_name(self : BundlePlan) -> String

#
BundlePlan::runtime_executable_path

source
fn BundlePlan::runtime_executable_path(self : BundlePlan) -> String

#
BundlePlan::runtime_manifest

source
fn BundlePlan::runtime_manifest(self : BundlePlan) -> Result[RuntimeLaunchManifest, Array[String]]

#
BundlePlan::runtime_manifest_json

source
fn BundlePlan::runtime_manifest_json(self : BundlePlan) -> Result[String, Array[String]]

#
BundlePlan::signing

source
fn BundlePlan::signing(self : BundlePlan) -> SigningConfig

#
BundlePlan::signing_prerequisites

source
fn BundlePlan::signing_prerequisites(self : BundlePlan) -> Array[SigningPrerequisite]

#
BundlePlan::signing_steps

source
fn BundlePlan::signing_steps(self : BundlePlan) -> Array[SigningStep]

#
BundlePlan::target

source
fn BundlePlan::target(self : BundlePlan) -> BundleTarget

#
BundlePlan::update_manifest

source
fn BundlePlan::update_manifest(self : BundlePlan, base_url~ : String, channel? : String, public_key? : String, artifact_trust? : Array[UpdateArtifactTrust]) -> Result[UpdateManifest, Array[String]]

#
BundlePlan::update_manifest_json

source
fn BundlePlan::update_manifest_json(self : BundlePlan, base_url~ : String, channel? : String, public_key? : String, artifact_trust? : Array[UpdateArtifactTrust]) -> Result[String, Array[String]]

#
BundleResource

source
pub struct BundleResource {
  kind : BundleResourceKind
  source_path : String
  path : String
} derive(Eq, 
Debug)

#
BundleResource::kind

source

#
BundleResource::new

source
fn BundleResource::new(kind~ : BundleResourceKind, source_path~ : String, path~ : String) -> BundleResource

#
BundleResource::path

source
fn BundleResource::path(self : BundleResource) -> String

#
BundleResource::source_path

source
fn BundleResource::source_path(self : BundleResource) -> String

#
BundleResource::to_json

source
fn BundleResource::to_json(self : BundleResource) -> String

#
BundleResourceKind

source
pub(all) enum BundleResourceKind {
  IconResource
  AssetResource
  ExecutableResource
} derive(Eq, 
Debug)

#
BundleResourceKind::name

source
fn BundleResourceKind::name(self : BundleResourceKind) -> String

#
BundleResourceSource

source
pub struct BundleResourceSource {
  source_path : String
  path : String
  executable : Bool
} derive(Eq, 
Debug)

#
BundleResourceSource::executable

source
fn BundleResourceSource::executable(self : BundleResourceSource) -> Bool

#
BundleResourceSource::new

source
fn BundleResourceSource::new(source_path~ : String, path~ : String, executable? : Bool) -> BundleResourceSource

#
BundleResourceSource::path

source
fn BundleResourceSource::path(self : BundleResourceSource) -> String

#
BundleResourceSource::source_path

source
fn BundleResourceSource::source_path(self : BundleResourceSource) -> String

#
BundleRuntimeDependency

source
pub struct BundleRuntimeDependency {
  kind : BundleRuntimeDependencyKind
  name : String
  path : String?
  source_path : String?
  required : Bool
  description : String
} derive(Eq, 
Debug)

#
BundleRuntimeDependency::description

source
fn BundleRuntimeDependency::description(self : BundleRuntimeDependency) -> String

#
BundleRuntimeDependency::kind

source

#
BundleRuntimeDependency::name

source

#
BundleRuntimeDependency::new

source
fn BundleRuntimeDependency::new(kind~ : BundleRuntimeDependencyKind, name~ : String, path? : String, source_path? : String, required? : Bool, description~ : String) -> BundleRuntimeDependency

#
BundleRuntimeDependency::path

source

#
BundleRuntimeDependency::required

source

#
BundleRuntimeDependency::source_path

source
fn BundleRuntimeDependency::source_path(self : BundleRuntimeDependency) -> String?

#
BundleRuntimeDependency::to_json

source
fn BundleRuntimeDependency::to_json(self : BundleRuntimeDependency) -> String

#
BundleRuntimeDependencyKind

source
pub(all) enum BundleRuntimeDependencyKind {
  SystemWebViewRuntime
  NativeLoaderLibrary
} derive(Eq, 
Debug)

#
BundleRuntimeDependencyKind::name

source

#
BundleRuntimeDependencySource

source
pub struct BundleRuntimeDependencySource {
  name : String
  source_path : String
} derive(Eq, 
Debug)

#
BundleRuntimeDependencySource::name

source

#
BundleRuntimeDependencySource::new

source
fn BundleRuntimeDependencySource::new(name~ : String, source_path~ : String) -> BundleRuntimeDependencySource

#
BundleRuntimeDependencySource::source_path

source

#
BundleTarget

source
pub(all) enum BundleTarget {
  MacOS
  Windows
  Linux
} derive(Eq, 
Debug)

#
BundleTarget::name

source
fn BundleTarget::name(self : BundleTarget) -> String

#
Capability

source
pub struct Capability {
  name : String
  windows : Array[String]
  origins : Array[String]
  platforms : Array[String]
  permissions : Array[Permission]
  operation_scopes : Array[OperationScope]
} derive(Eq, 
Debug)

#
Capability::allows

source
fn Capability::allows(self : Capability, window_label~ : String, permission~ : Permission, origin? : String, platform? : String) -> Bool

#
Capability::allows_operation

source
fn Capability::allows_operation(self : Capability, window_label~ : String, permission~ : Permission, scope~ : OperationScope, origin? : String, platform? : String) -> Bool

#
Capability::command

source
fn Capability::command(self : Capability, route : String) -> Capability

#
Capability::name

source
fn Capability::name(self : Capability) -> String

#
Capability::new

source
fn Capability::new(name : String) -> Capability

#
Capability::operation_scope

source
fn Capability::operation_scope(self : Capability, scope : OperationScope) -> Capability

#
Capability::operation_scopes

source
fn Capability::operation_scopes(self : Capability) -> Array[OperationScope]

#
Capability::operation_scopes_by_kind

source
fn Capability::operation_scopes_by_kind(self : Capability, kind : OperationScopeKind) -> Array[OperationScope]

#
Capability::origin

source
fn Capability::origin(self : Capability, origin : String) -> Capability

#
Capability::origins

source
fn Capability::origins(self : Capability) -> Array[String]

#
Capability::path_scope

source
fn Capability::path_scope(self : Capability, root~ : String, writable? : Bool) -> Capability

#
Capability::permission

source
fn Capability::permission(self : Capability, permission : Permission) -> Capability

#
Capability::permissions

source
fn Capability::permissions(self : Capability) -> Array[Permission]

#
Capability::platform

source
fn Capability::platform(self : Capability, platform : String) -> Capability

#
Capability::platforms

source
fn Capability::platforms(self : Capability) -> Array[String]

#
Capability::shell_scope

source
fn Capability::shell_scope(self : Capability, command : String) -> Capability

#
Capability::url_scope

source
fn Capability::url_scope(self : Capability, origin : String) -> Capability

#
Capability::validate

source
fn Capability::validate(self : Capability) -> Array[String]

#
Capability::window

source
fn Capability::window(self : Capability, label : String) -> Capability

#
Capability::windows

source
fn Capability::windows(self : Capability) -> Array[String]

#
Capability::with_file_system_scopes

source
fn Capability::with_file_system_scopes(self : Capability, scopes : Array[FileSystemScope]) -> Capability

#
CapabilityCompileIssue

source
pub struct CapabilityCompileIssue {
  severity : CapabilityIssueSeverity
  code : String
  message : String
  plugin : String
  route : String
  permission : String
  capability : String
  window_label : String
} derive(Eq, 
Debug)

#
CapabilityCompileIssue::capability

source
fn CapabilityCompileIssue::capability(self : CapabilityCompileIssue) -> String

#
CapabilityCompileIssue::code

source

#
CapabilityCompileIssue::message

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

#
CapabilityCompileIssue::permission

source
fn CapabilityCompileIssue::permission(self : CapabilityCompileIssue) -> String

#
CapabilityCompileIssue::plugin

source
fn CapabilityCompileIssue::plugin(self : CapabilityCompileIssue) -> String

#
CapabilityCompileIssue::route

source

#
CapabilityCompileIssue::severity

source

#
CapabilityCompileIssue::to_json

source
fn CapabilityCompileIssue::to_json(self : CapabilityCompileIssue) -> String

#
CapabilityCompileIssue::window_label

source
fn CapabilityCompileIssue::window_label(self : CapabilityCompileIssue) -> String

#
CapabilityCompileReport

source
pub struct CapabilityCompileReport {
  plugin_contracts : Array[PluginContract]
  command_manifest : CommandManifest
  permission_manifest : PermissionManifest
  issues : Array[CapabilityCompileIssue]
} derive(Eq, 
Debug)

#
CapabilityCompileReport::command_manifest

source

#
CapabilityCompileReport::denied_routes

source
fn CapabilityCompileReport::denied_routes(self : CapabilityCompileReport) -> Array[String]

#
CapabilityCompileReport::error_count

source
fn CapabilityCompileReport::error_count(self : CapabilityCompileReport) -> Int

#
CapabilityCompileReport::errors

source

#
CapabilityCompileReport::from_plugins

source
fn CapabilityCompileReport::from_plugins(plugins~ : Array[Plugin], capabilities~ : Array[Capability], windows~ : Array[ResolvedWindow]) -> CapabilityCompileReport

#
CapabilityCompileReport::issues

source

#
CapabilityCompileReport::ok

source

#
CapabilityCompileReport::permission_manifest

source

#
CapabilityCompileReport::plugin_contracts

source

#
CapabilityCompileReport::to_json

source
fn CapabilityCompileReport::to_json(self : CapabilityCompileReport) -> String

#
CapabilityCompileReport::unknown_windows

source
fn CapabilityCompileReport::unknown_windows(self : CapabilityCompileReport) -> Array[String]

#
CapabilityCompileReport::unused_permissions

source
fn CapabilityCompileReport::unused_permissions(self : CapabilityCompileReport) -> Array[String]

#
CapabilityCompileReport::warning_count

source
fn CapabilityCompileReport::warning_count(self : CapabilityCompileReport) -> Int

#
CapabilityCompileReport::warnings

source

#
CapabilityDecision

source
pub struct CapabilityDecision {
  allowed : Bool
  window_label : String
  origin : String
  platform : String
  permission : Permission
  capability : String
  reason : String
} derive(Eq, 
Debug)

#
CapabilityDecision::allowed

source
fn CapabilityDecision::allowed(self : CapabilityDecision) -> Bool

#
CapabilityDecision::capability

source
fn CapabilityDecision::capability(self : CapabilityDecision) -> String

#
CapabilityDecision::denied

source
fn CapabilityDecision::denied(self : CapabilityDecision) -> Bool

#
CapabilityDecision::origin

source
fn CapabilityDecision::origin(self : CapabilityDecision) -> String

#
CapabilityDecision::permission

source

#
CapabilityDecision::platform

source
fn CapabilityDecision::platform(self : CapabilityDecision) -> String

#
CapabilityDecision::reason

source
fn CapabilityDecision::reason(self : CapabilityDecision) -> String

#
CapabilityDecision::to_json

source
fn CapabilityDecision::to_json(self : CapabilityDecision) -> String

#
CapabilityDecision::window_label

source
fn CapabilityDecision::window_label(self : CapabilityDecision) -> String

#
CapabilityIssueSeverity

source
pub(all) enum CapabilityIssueSeverity {
  CapabilityWarning
  CapabilityError
} derive(Eq, 
Debug)

#
CapabilityIssueSeverity::is_error

source

#
CapabilityIssueSeverity::name

source

#
CapabilityPolicy

source
pub struct CapabilityPolicy {
  capabilities : Array[Capability]
} derive(Eq, 
Debug)

#
CapabilityPolicy::allowed_origins

source
fn CapabilityPolicy::allowed_origins(self : CapabilityPolicy, window_label~ : String, permission~ : Permission, platform? : String) -> Array[String]

#
CapabilityPolicy::allows

source
fn CapabilityPolicy::allows(self : CapabilityPolicy, window_label~ : String, permission~ : Permission, origin? : String, platform? : String) -> Bool

#
CapabilityPolicy::allows_operation

source
fn CapabilityPolicy::allows_operation(self : CapabilityPolicy, window_label~ : String, permission~ : Permission, scope~ : OperationScope, origin? : String, platform? : String) -> Bool

#
CapabilityPolicy::allows_window

source
fn CapabilityPolicy::allows_window(self : CapabilityPolicy, window_label~ : String, permission~ : Permission, platform? : String) -> Bool

#
CapabilityPolicy::capabilities

source
fn CapabilityPolicy::capabilities(self : CapabilityPolicy) -> Array[Capability]

#
CapabilityPolicy::evaluate

source
fn CapabilityPolicy::evaluate(self : CapabilityPolicy, window_label~ : String, permission~ : Permission, origin? : String, platform? : String) -> CapabilityDecision

#
CapabilityPolicy::evaluate_operation

source
fn CapabilityPolicy::evaluate_operation(self : CapabilityPolicy, window_label~ : String, permission~ : Permission, scope~ : OperationScope, origin? : String, platform? : String) -> CapabilityDecision

#
CapabilityPolicy::new

source
fn CapabilityPolicy::new(capabilities? : Array[Capability]) -> CapabilityPolicy

#
CapabilityPolicy::to_json

source
fn CapabilityPolicy::to_json(self : CapabilityPolicy) -> String

#
CapabilityPolicy::validate

source
fn CapabilityPolicy::validate(self : CapabilityPolicy) -> Array[String]

#
Cell

source
pub struct Cell {
  id : String
  html : Html
} derive(Eq, 
Debug)

#
Cell::html

source
fn Cell::html(self : Cell) -> Html

#
Cell::id

source
fn Cell::id(self : Cell) -> String

#
Cell::new

source
fn Cell::new(id? : String, html? : Html) -> Cell

#
Channel

source
pub struct Channel {
  resource : ResourceEntry
  next_sequence : Int
  messages : Array[ChannelMessage]
  closed : Bool
  cancelled : Bool
} derive(Eq, 
Debug)

#
Channel::cancelled

source
fn Channel::cancelled(self : Channel) -> Bool

#
Channel::closed

source
fn Channel::closed(self : Channel) -> Bool

#
Channel::id

source
fn Channel::id(self : Channel) -> String

#
Channel::pending_count

source
fn Channel::pending_count(self : Channel) -> Int

#
Channel::resource

source
fn Channel::resource(self : Channel) -> ResourceEntry

#
Channel::to_json

source
fn Channel::to_json(self : Channel) -> String

#
ChannelMessage

source
pub struct ChannelMessage {
  channel_id : String
  sequence : Int
  kind : ChannelMessageKind
  payload : String
} derive(Eq, 
Debug)

#
ChannelMessage::channel_id

source
fn ChannelMessage::channel_id(self : ChannelMessage) -> String

#
ChannelMessage::kind

source

#
ChannelMessage::payload

source
fn ChannelMessage::payload(self : ChannelMessage) -> String

#
ChannelMessage::sequence

source
fn ChannelMessage::sequence(self : ChannelMessage) -> Int

#
ChannelMessage::to_json

source
fn ChannelMessage::to_json(self : ChannelMessage) -> String

#
ChannelMessageKind

source
pub(all) enum ChannelMessageKind {
  ChannelData
  ChannelError
  ChannelEnd
  ChannelCancel
} derive(Eq, 
Debug)

#
ChannelMessageKind::name

source
fn ChannelMessageKind::name(self : ChannelMessageKind) -> String

#
ChannelTable

source
pub struct ChannelTable {
  resources : ResourceTable
  channels : Map[String, Channel]
  order : Array[String]
}

#
ChannelTable::cancel

source
fn ChannelTable::cancel(self : ChannelTable, id : String) -> Result[ChannelMessage, String]

#
ChannelTable::channels

source
fn ChannelTable::channels(self : ChannelTable) -> Array[Channel]

#
ChannelTable::cleanup_report

source
fn ChannelTable::cleanup_report(self : ChannelTable) -> ResourceCleanupReport

#
ChannelTable::close

source
fn ChannelTable::close(self : ChannelTable, id : String) -> Result[ResourceEntry, String]

#
ChannelTable::close_all

source
fn ChannelTable::close_all(self : ChannelTable) -> Array[ResourceEntry]

#
ChannelTable::contains

source
fn ChannelTable::contains(self : ChannelTable, id : String) -> Bool

#
ChannelTable::count

source
fn ChannelTable::count(self : ChannelTable) -> Int

#
ChannelTable::drain

source
fn ChannelTable::drain(self : ChannelTable, id : String) -> Result[Array[ChannelMessage], String]

#
ChannelTable::end

source
fn ChannelTable::end(self : ChannelTable, id : String) -> Result[ChannelMessage, String]

#
ChannelTable::fail

source
fn ChannelTable::fail(self : ChannelTable, id : String, message : String) -> Result[ChannelMessage, String]

#
ChannelTable::get

source
fn ChannelTable::get(self : ChannelTable, id : String) -> Channel?

#
ChannelTable::ids

source
fn ChannelTable::ids(self : ChannelTable) -> Array[String]

#
ChannelTable::leak_report

source
fn ChannelTable::leak_report(self : ChannelTable) -> ResourceLeakReport

#
ChannelTable::new

source

#
ChannelTable::open

source
fn ChannelTable::open(self : ChannelTable, owner? : String, name? : String, metadata? : String) -> Result[Channel, Array[String]]

#
ChannelTable::resource_entries

source
fn ChannelTable::resource_entries(self : ChannelTable) -> Array[ResourceEntry]

#
ChannelTable::send

source
fn ChannelTable::send(self : ChannelTable, id : String, payload : String) -> Result[ChannelMessage, String]

#
ChannelTable::to_json

source
fn ChannelTable::to_json(self : ChannelTable) -> String

#
Cmd

source
pub(all) enum Cmd {
  None
  Batch(Array[Cmd])
  Effect(String)
  Emit(EventTarget, Event)
  Navigate(String, Source)
} derive(Eq, 
Debug)

#
Cmd::batch

source
fn Cmd::batch(commands : Array[Cmd]) -> Cmd

#
Cmd::effect

source
fn Cmd::effect(name : String) -> Cmd

#
Cmd::emit

source
fn Cmd::emit(event : Event, target? : EventTarget) -> Cmd

#
Cmd::is_empty

source
fn Cmd::is_empty(self : Cmd) -> Bool

#
Cmd::navigate

source
fn Cmd::navigate(window_label : String, source : Source) -> Cmd

#
CommandExecutionAffinity

source
pub(all) enum CommandExecutionAffinity {
  MainThread
  WorkerThread
  AnyThread
} derive(Eq, 
Debug)

#
CommandExecutionAffinity::name

source

#
CommandManifest

source
pub struct CommandManifest {
  entries : Array[CommandManifestEntry]
} derive(Eq, 
Debug)

#
CommandManifest::allowed_routes

source
fn CommandManifest::allowed_routes(self : CommandManifest, window_label : String) -> Array[String]

#
CommandManifest::allows

source
fn CommandManifest::allows(self : CommandManifest, route : String, window_label~ : String, origin? : String, platform? : String) -> Bool

#
CommandManifest::entries

source

#
CommandManifest::entry

source
fn CommandManifest::entry(self : CommandManifest, route : String) -> CommandManifestEntry?

#
CommandManifest::from_plugins

source
fn CommandManifest::from_plugins(plugins~ : Array[Plugin], capabilities~ : Array[Capability], windows~ : Array[ResolvedWindow], platform? : String) -> CommandManifest

#
CommandManifest::new

source

#
CommandManifest::routes

source
fn CommandManifest::routes(self : CommandManifest) -> Array[String]

#
CommandManifest::routes_by_affinity

source
fn CommandManifest::routes_by_affinity(self : CommandManifest, affinity : CommandExecutionAffinity) -> Array[String]

#
CommandManifest::routes_by_mode

source
fn CommandManifest::routes_by_mode(self : CommandManifest, mode : CommandMode) -> Array[String]

#
CommandManifest::to_json

source
fn CommandManifest::to_json(self : CommandManifest) -> String

#
CommandManifestEntry

source
pub struct CommandManifestEntry {
  plugin : String
  command : String
  route : String
  mode : CommandMode
  affinity : CommandExecutionAffinity
  permission : Permission
  request_schema : IpcSchema
  response_schema : IpcSchema
  allowed_windows : Array[String]
  allowed_origins : Array[String]
  allowed_platforms : Array[String]
} derive(Eq, 
Debug)

#
CommandManifestEntry::affinity

source

#
CommandManifestEntry::allowed_for_origin

source
fn CommandManifestEntry::allowed_for_origin(self : CommandManifestEntry, origin : String) -> Bool

#
CommandManifestEntry::allowed_in_window

source
fn CommandManifestEntry::allowed_in_window(self : CommandManifestEntry, window_label : String) -> Bool

#
CommandManifestEntry::allowed_on_platform

source
fn CommandManifestEntry::allowed_on_platform(self : CommandManifestEntry, platform : String) -> Bool

#
CommandManifestEntry::allowed_origins

source
fn CommandManifestEntry::allowed_origins(self : CommandManifestEntry) -> Array[String]

#
CommandManifestEntry::allowed_platforms

source
fn CommandManifestEntry::allowed_platforms(self : CommandManifestEntry) -> Array[String]

#
CommandManifestEntry::allowed_windows

source
fn CommandManifestEntry::allowed_windows(self : CommandManifestEntry) -> Array[String]

#
CommandManifestEntry::command

source
fn CommandManifestEntry::command(self : CommandManifestEntry) -> String

#
CommandManifestEntry::mode

source

#
CommandManifestEntry::permission

source

#
CommandManifestEntry::plugin

source
fn CommandManifestEntry::plugin(self : CommandManifestEntry) -> String

#
CommandManifestEntry::request_schema

source

#
CommandManifestEntry::response_schema

source
fn CommandManifestEntry::response_schema(self : CommandManifestEntry) -> IpcSchema

#
CommandManifestEntry::route

source
fn CommandManifestEntry::route(self : CommandManifestEntry) -> String

#
CommandManifestEntry::to_json

source
fn CommandManifestEntry::to_json(self : CommandManifestEntry) -> String

#
CommandMode

source
pub(all) enum CommandMode {
  Sync
  Async
  Stream
  Event
} derive(Eq, 
Debug)

#
CommandMode::name

source
fn CommandMode::name(self : CommandMode) -> String

#
CommandRegistry

source
pub struct CommandRegistry {
  commands : Map[String, RegisteredCommand]
  duplicate_routes : Array[String]
}

#
CommandRegistry::async_routes

source
fn CommandRegistry::async_routes(self : CommandRegistry) -> Array[String]

#
CommandRegistry::contains

source
fn CommandRegistry::contains(self : CommandRegistry, route : String) -> Bool

#
CommandRegistry::dispatch

source
fn CommandRegistry::dispatch(self : CommandRegistry, request : InvokeRequest, capabilities? : Array[Capability]) -> InvokeResponse

#
CommandRegistry::dispatch_async

source
async fn CommandRegistry::dispatch_async(self : CommandRegistry, request : InvokeRequest, capabilities? : Array[Capability]) -> InvokeResponse

#
CommandRegistry::dispatch_with_permission

source
fn CommandRegistry::dispatch_with_permission(self : CommandRegistry, request : InvokeRequest, permission~ : Permission, capabilities? : Array[Capability]) -> InvokeResponse

#
CommandRegistry::dispatch_with_permission_async

source
async fn CommandRegistry::dispatch_with_permission_async(self : CommandRegistry, request : InvokeRequest, permission~ : Permission, capabilities? : Array[Capability]) -> InvokeResponse

#
CommandRegistry::dispatch_with_profile

source
fn CommandRegistry::dispatch_with_profile(self : CommandRegistry, profile : SecurityProfile, request : InvokeRequest) -> InvokeResponse

#
CommandRegistry::dispatch_with_profile_async

source
async fn CommandRegistry::dispatch_with_profile_async(self : CommandRegistry, profile : SecurityProfile, request : InvokeRequest) -> InvokeResponse

#
CommandRegistry::invoke_contract

source
fn CommandRegistry::invoke_contract(self : CommandRegistry, profile : SecurityProfile, route : String) -> InvokeContract?

#
CommandRegistry::invoke_contract_report

source
fn CommandRegistry::invoke_contract_report(self : CommandRegistry, profile : SecurityProfile) -> InvokeContractReport

#
CommandRegistry::invoke_contracts

source
fn CommandRegistry::invoke_contracts(self : CommandRegistry, profile : SecurityProfile) -> Array[InvokeContract]

#
CommandRegistry::merge

source

#
CommandRegistry::new

source

#
CommandRegistry::register

source

#
CommandRegistry::register_async_fn

source
fn CommandRegistry::register_async_fn(self : CommandRegistry, route : String, permission? : Permission, operation_scope? : (InvokeRequest) -> Result[OperationScope, String], handler~ : async (String) -> Result[String, String]) -> CommandRegistry

#
CommandRegistry::register_fn

source
fn CommandRegistry::register_fn(self : CommandRegistry, route : String, permission? : Permission, operation_scope? : (InvokeRequest) -> Result[OperationScope, String], handler~ : (String) -> Result[String, String]) -> CommandRegistry

#
CommandRegistry::register_stream_fn

source
fn CommandRegistry::register_stream_fn(self : CommandRegistry, route : String, permission? : Permission, operation_scope? : (InvokeRequest) -> Result[OperationScope, String], handler~ : (String, StreamSink) -> Result[Unit, String]) -> CommandRegistry

#
CommandRegistry::routes

source
fn CommandRegistry::routes(self : CommandRegistry) -> Array[String]

#
CommandRegistry::sync_routes

source
fn CommandRegistry::sync_routes(self : CommandRegistry) -> Array[String]

#
CommandRegistry::validate

source
fn CommandRegistry::validate(self : CommandRegistry) -> Array[String]

#
CommandSpec

source
pub struct CommandSpec {
  name : String
  mode : CommandMode
  affinity : CommandExecutionAffinity
  permission : Permission
  request_schema : IpcSchema
  response_schema : IpcSchema
} derive(Eq, 
Debug)

#
CommandSpec::affinity

source

#
CommandSpec::mode

source
fn CommandSpec::mode(self : CommandSpec) -> CommandMode

#
CommandSpec::name

source
fn CommandSpec::name(self : CommandSpec) -> String

#
CommandSpec::new

source
fn CommandSpec::new(name : String, mode? : CommandMode, affinity? : CommandExecutionAffinity, permission? : Permission, request? : IpcSchema, response? : IpcSchema) -> CommandSpec

#
CommandSpec::permission

source
fn CommandSpec::permission(self : CommandSpec) -> Permission

#
CommandSpec::request_schema

source
fn CommandSpec::request_schema(self : CommandSpec) -> IpcSchema

#
CommandSpec::response_schema

source
fn CommandSpec::response_schema(self : CommandSpec) -> IpcSchema

#
CommandSpec::with_affinity

source
fn CommandSpec::with_affinity(self : CommandSpec, affinity : CommandExecutionAffinity) -> CommandSpec

#
CommandSpec::with_schema

source
fn CommandSpec::with_schema(self : CommandSpec, request? : IpcSchema, response? : IpcSchema) -> CommandSpec

#
Event

source
pub struct Event {
  name : String
  payload : String
} derive(Eq, 
Debug)

#
Event::name

source
fn Event::name(self : Event) -> String

#
Event::new

source
fn Event::new(name : String, payload? : String) -> Event

#
Event::payload

source
fn Event::payload(self : Event) -> String

#
Event::to_json

source
fn Event::to_json(self : Event) -> String

#
Event::validate

source
fn Event::validate(self : Event) -> Array[String]

#
EventBus

source
pub struct EventBus {
  next_listener_sequence : Int
  listeners : Map[String, EventListener]
  order : Array[String]
} derive(Eq, 
Debug)

#
EventBus::clear

source
fn EventBus::clear(self : EventBus) -> Array[EventListener]

#
EventBus::emit

source
fn EventBus::emit(self : EventBus, event : Event, target? : EventTarget) -> Result[Array[EventDelivery], Array[String]]

#
EventBus::listen

source
fn EventBus::listen(self : EventBus, name : String, target? : EventTarget, once? : Bool) -> Result[EventListener, Array[String]]

#
EventBus::listener

source
fn EventBus::listener(self : EventBus, id : String) -> EventListener?

#
EventBus::listener_count

source
fn EventBus::listener_count(self : EventBus) -> Int

#
EventBus::listeners

source
fn EventBus::listeners(self : EventBus) -> Array[EventListener]

#
EventBus::listeners_for

source
fn EventBus::listeners_for(self : EventBus, name : String, target? : EventTarget) -> Array[EventListener]

#
EventBus::new

source
fn EventBus::new() -> EventBus

#
EventBus::once

source
fn EventBus::once(self : EventBus, name : String, target? : EventTarget) -> Result[EventListener, Array[String]]

#
EventBus::remove_target

source
fn EventBus::remove_target(self : EventBus, target : EventTarget) -> Array[EventListener]

#
EventBus::to_json

source
fn EventBus::to_json(self : EventBus) -> String

#
EventBus::unlisten

source
fn EventBus::unlisten(self : EventBus, id : String) -> Result[EventListener, String]

#
EventDelivery

source
pub struct EventDelivery {
  listener_id : String
  target : EventTarget
  event : Event
} derive(Eq, 
Debug)

#
EventDelivery::event

source
fn EventDelivery::event(self : EventDelivery) -> Event

#
EventDelivery::listener_id

source
fn EventDelivery::listener_id(self : EventDelivery) -> String

#
EventDelivery::target

source

#
EventDelivery::to_json

source
fn EventDelivery::to_json(self : EventDelivery) -> String

#
EventListener

source
pub struct EventListener {
  id : String
  name : String
  target : EventTarget
  once : Bool
} derive(Eq, 
Debug)

#
EventListener::id

source
fn EventListener::id(self : EventListener) -> String

#
EventListener::name

source
fn EventListener::name(self : EventListener) -> String

#
EventListener::once

source
fn EventListener::once(self : EventListener) -> Bool

#
EventListener::target

source

#
EventListener::to_json

source
fn EventListener::to_json(self : EventListener) -> String

#
EventTarget

source
pub(all) enum EventTarget {
  AppTarget
  WindowTarget(String)
  WebviewTarget(String)
} derive(Eq, 
Debug)

#
EventTarget::kind

source
fn EventTarget::kind(self : EventTarget) -> String

#
EventTarget::label

source
fn EventTarget::label(self : EventTarget) -> String?

#
EventTarget::to_json

source
fn EventTarget::to_json(self : EventTarget) -> String

#
EventTarget::validate

source
fn EventTarget::validate(self : EventTarget) -> Array[String]

#
FileSystemScope

source
pub struct FileSystemScope {
  name : String
  root : String
  writable : Bool
} derive(Eq, 
Debug)

#
FileSystemScope::name

source
fn FileSystemScope::name(self : FileSystemScope) -> String

#
FileSystemScope::new

source
fn FileSystemScope::new(name~ : String, root~ : String, writable? : Bool) -> FileSystemScope

#
FileSystemScope::root

source
fn FileSystemScope::root(self : FileSystemScope) -> String

#
FileSystemScope::to_json

source
fn FileSystemScope::to_json(self : FileSystemScope) -> String

#
FileSystemScope::validate

source
fn FileSystemScope::validate(self : FileSystemScope) -> Array[String]

#
FileSystemScope::writable

source
fn FileSystemScope::writable(self : FileSystemScope) -> Bool

#
FrontendEventDispatch

source
pub struct FrontendEventDispatch {
  window_label : String
  hook : String
  event : Event
  script : String
} derive(Eq, 
Debug)

#
FrontendEventDispatch::event

source

#
FrontendEventDispatch::hook

source
fn FrontendEventDispatch::hook(self : FrontendEventDispatch) -> String

#
FrontendEventDispatch::new

source
fn FrontendEventDispatch::new(window_label~ : String, hook? : String, event~ : Event) -> FrontendEventDispatch

#
FrontendEventDispatch::script

source
fn FrontendEventDispatch::script(self : FrontendEventDispatch) -> String

#
FrontendEventDispatch::to_json

source
fn FrontendEventDispatch::to_json(self : FrontendEventDispatch) -> String

#
FrontendEventDispatch::window_label

source
fn FrontendEventDispatch::window_label(self : FrontendEventDispatch) -> String

#
Html

source
pub struct Html {
  content : String
} derive(Eq, 
Debug)

#
Html::content

source
fn Html::content(self : Html) -> String

#
Html::empty

source
fn Html::empty() -> Html

#
Html::text

source
fn Html::text(content : String) -> Html

#
InvokeContract

source
pub struct InvokeContract {
  route : String
  plugin : String
  command : String
  mode : CommandMode
  affinity : CommandExecutionAffinity
  permission : Permission
  request_schema : IpcSchema
  response_schema : IpcSchema
  allowed_windows : Array[String]
  allowed_origins : Array[String]
  requires_registered_handler : Bool
  registered : Bool
  registered_mode : CommandMode?
  registered_permission : Permission?
  exposed : Bool
  operation_scope_configured : Bool
  operation_scope_required : Bool
  problems : Array[String]
} derive(Eq, 
Debug)

#
InvokeContract::affinity

source

#
InvokeContract::allowed_origins

source
fn InvokeContract::allowed_origins(self : InvokeContract) -> Array[String]

#
InvokeContract::allowed_windows

source
fn InvokeContract::allowed_windows(self : InvokeContract) -> Array[String]

#
InvokeContract::command

source
fn InvokeContract::command(self : InvokeContract) -> String

#
InvokeContract::dispatchable

source
fn InvokeContract::dispatchable(self : InvokeContract) -> Bool

#
InvokeContract::exposed

source
fn InvokeContract::exposed(self : InvokeContract) -> Bool

#
InvokeContract::mode

source

#
InvokeContract::ok

source
fn InvokeContract::ok(self : InvokeContract) -> Bool

#
InvokeContract::operation_scope_configured

source
fn InvokeContract::operation_scope_configured(self : InvokeContract) -> Bool

#
InvokeContract::operation_scope_required

source
fn InvokeContract::operation_scope_required(self : InvokeContract) -> Bool

#
InvokeContract::permission

source
fn InvokeContract::permission(self : InvokeContract) -> Permission

#
InvokeContract::plugin

source
fn InvokeContract::plugin(self : InvokeContract) -> String

#
InvokeContract::problems

source
fn InvokeContract::problems(self : InvokeContract) -> Array[String]

#
InvokeContract::registered

source
fn InvokeContract::registered(self : InvokeContract) -> Bool

#
InvokeContract::registered_mode

source
fn InvokeContract::registered_mode(self : InvokeContract) -> CommandMode?

#
InvokeContract::registered_permission

source
fn InvokeContract::registered_permission(self : InvokeContract) -> Permission?

#
InvokeContract::request_schema

source
fn InvokeContract::request_schema(self : InvokeContract) -> IpcSchema

#
InvokeContract::requires_registered_handler

source
fn InvokeContract::requires_registered_handler(self : InvokeContract) -> Bool

#
InvokeContract::response_schema

source
fn InvokeContract::response_schema(self : InvokeContract) -> IpcSchema

#
InvokeContract::route

source
fn InvokeContract::route(self : InvokeContract) -> String

#
InvokeContract::to_json

source
fn InvokeContract::to_json(self : InvokeContract) -> String

#
InvokeContractReport

source
pub struct InvokeContractReport {
  contracts : Array[InvokeContract]
  undeclared_routes : Array[String]
  duplicate_routes : Array[String]
  problems : Array[String]
} derive(Eq, 
Debug)

#
InvokeContractReport::contracts

source

#
InvokeContractReport::dispatchable_routes

source
fn InvokeContractReport::dispatchable_routes(self : InvokeContractReport) -> Array[String]

#
InvokeContractReport::duplicate_routes

source
fn InvokeContractReport::duplicate_routes(self : InvokeContractReport) -> Array[String]

#
InvokeContractReport::ok

source

#
InvokeContractReport::problems

source
fn InvokeContractReport::problems(self : InvokeContractReport) -> Array[String]

#
InvokeContractReport::to_json

source
fn InvokeContractReport::to_json(self : InvokeContractReport) -> String

#
InvokeContractReport::undeclared_routes

source
fn InvokeContractReport::undeclared_routes(self : InvokeContractReport) -> Array[String]

#
InvokeErrorKind

source
pub(all) enum InvokeErrorKind {
  InvalidRequest
  UnknownCommand
  PermissionDenied
  AsyncRequired
  HandlerError
  TransportError
  Timeout
  Cancelled
} derive(Eq, 
Debug)

#
InvokeErrorKind::name

source
fn InvokeErrorKind::name(self : InvokeErrorKind) -> String

#
InvokeFailure

source
pub struct InvokeFailure {
  kind : InvokeErrorKind
  message : String
  route : String
} derive(Eq, 
Debug)

#
InvokeFailure::async_required

source
fn InvokeFailure::async_required(route : String) -> InvokeFailure

#
InvokeFailure::cancelled

source
fn InvokeFailure::cancelled(message? : String, route? : String) -> InvokeFailure

#
InvokeFailure::handler_error

source
fn InvokeFailure::handler_error(message : String, route? : String) -> InvokeFailure

#
InvokeFailure::invalid_request

source
fn InvokeFailure::invalid_request(message : String) -> InvokeFailure

#
InvokeFailure::kind

source

#
InvokeFailure::message

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

#
InvokeFailure::new

source
fn InvokeFailure::new(kind~ : InvokeErrorKind, message~ : String, route? : String) -> InvokeFailure

#
InvokeFailure::permission_denied

source
fn InvokeFailure::permission_denied(route : String) -> InvokeFailure

#
InvokeFailure::route

source
fn InvokeFailure::route(self : InvokeFailure) -> String?

#
InvokeFailure::timeout

source
fn InvokeFailure::timeout(message? : String, route? : String) -> InvokeFailure

#
InvokeFailure::to_json

source
fn InvokeFailure::to_json(self : InvokeFailure) -> String

#
InvokeFailure::transport_error

source
fn InvokeFailure::transport_error(message : String) -> InvokeFailure

#
InvokeFailure::unknown_command

source
fn InvokeFailure::unknown_command(route : String) -> InvokeFailure

#
InvokeRequest

source
pub struct InvokeRequest {
  id : String
  window_label : String
  plugin : String
  command : String
  payload : String
  origin : String
  callback_id : String
  error_id : String
} derive(Eq, 
Debug)

#
InvokeRequest::callback_id

source
fn InvokeRequest::callback_id(self : InvokeRequest) -> String

#
InvokeRequest::command

source
fn InvokeRequest::command(self : InvokeRequest) -> String

#
InvokeRequest::error_id

source
fn InvokeRequest::error_id(self : InvokeRequest) -> String

#
InvokeRequest::has_resolver_ids

source
fn InvokeRequest::has_resolver_ids(self : InvokeRequest) -> Bool

#
InvokeRequest::id

source
fn InvokeRequest::id(self : InvokeRequest) -> String

#
InvokeRequest::new

source
fn InvokeRequest::new(id~ : String, window_label~ : String, plugin~ : String, command~ : String, payload? : String, origin? : String, callback_id? : String, error_id? : String) -> InvokeRequest

#
InvokeRequest::origin

source
fn InvokeRequest::origin(self : InvokeRequest) -> String

#
InvokeRequest::payload

source
fn InvokeRequest::payload(self : InvokeRequest) -> String

#
InvokeRequest::plugin

source
fn InvokeRequest::plugin(self : InvokeRequest) -> String

#
InvokeRequest::route

source
fn InvokeRequest::route(self : InvokeRequest) -> String

#
InvokeRequest::validate

source
fn InvokeRequest::validate(self : InvokeRequest) -> Array[String]

#
InvokeRequest::window_label

source
fn InvokeRequest::window_label(self : InvokeRequest) -> String

#
InvokeResponse

source
pub(all) enum InvokeResponse {
  InvokeOk(String, String)
  InvokeError(String, InvokeFailure)
} derive(Eq, 
Debug)

#
InvokeResponse::async_required

source
fn InvokeResponse::async_required(id : String, route : String) -> InvokeResponse

#
InvokeResponse::error

source
fn InvokeResponse::error(id : String, message : String) -> InvokeResponse

#
InvokeResponse::error_kind

source
fn InvokeResponse::error_kind(self : InvokeResponse) -> InvokeErrorKind?

#
InvokeResponse::error_message

source
fn InvokeResponse::error_message(self : InvokeResponse) -> String?

#
InvokeResponse::failure

source
fn InvokeResponse::failure(id : String, failure : InvokeFailure) -> InvokeResponse

#
InvokeResponse::failure_info

source
fn InvokeResponse::failure_info(self : InvokeResponse) -> InvokeFailure?

#
InvokeResponse::handler_error

source
fn InvokeResponse::handler_error(id : String, message : String, route? : String) -> InvokeResponse

#
InvokeResponse::id

source
fn InvokeResponse::id(self : InvokeResponse) -> String

#
InvokeResponse::invalid_request

source
fn InvokeResponse::invalid_request(id : String, message : String) -> InvokeResponse

#
InvokeResponse::ok

source
fn InvokeResponse::ok(id : String, payload : String) -> InvokeResponse

#
InvokeResponse::payload

source
fn InvokeResponse::payload(self : InvokeResponse) -> String?

#
InvokeResponse::permission_denied

source
fn InvokeResponse::permission_denied(id : String, route : String) -> InvokeResponse

#
InvokeResponse::unknown_command

source
fn InvokeResponse::unknown_command(id : String, route : String) -> InvokeResponse

#
IpcSchema

source
pub struct IpcSchema {
  name : String
  typescript : String
  description : String
} derive(Eq, 
Debug)

#
IpcSchema::accepts_payload

source
fn IpcSchema::accepts_payload(self : IpcSchema, payload : String) -> Bool

#
IpcSchema::any

source
fn IpcSchema::any() -> IpcSchema

#
IpcSchema::array

source
fn IpcSchema::array(item : IpcSchema) -> IpcSchema

#
IpcSchema::boolean

source
fn IpcSchema::boolean() -> IpcSchema

#
IpcSchema::description

source
fn IpcSchema::description(self : IpcSchema) -> String

#
IpcSchema::json

source
fn IpcSchema::json() -> IpcSchema

#
IpcSchema::name

source
fn IpcSchema::name(self : IpcSchema) -> String

#
IpcSchema::new

source
fn IpcSchema::new(name~ : String, typescript? : String, description? : String) -> IpcSchema

#
IpcSchema::number

source
fn IpcSchema::number() -> IpcSchema

#
IpcSchema::object

source
fn IpcSchema::object(name : String, typescript : String, description? : String) -> IpcSchema

#
IpcSchema::string

source
fn IpcSchema::string() -> IpcSchema

#
IpcSchema::to_json

source
fn IpcSchema::to_json(self : IpcSchema) -> String

#
IpcSchema::typescript

source
fn IpcSchema::typescript(self : IpcSchema) -> String

#
IpcSchema::unit

source
fn IpcSchema::unit() -> IpcSchema

#
IpcSchema::validate

source
fn IpcSchema::validate(self : IpcSchema) -> Array[String]

#
IpcSchema::validate_payload

source
fn IpcSchema::validate_payload(self : IpcSchema, payload : String) -> String?

#
LaunchPlan

source
pub struct LaunchPlan {
  root : Cell
  windows : Array[WindowConfig]
  plugins : Array[Plugin]
  capabilities : Array[Capability]
  startup : Cmd
  lifecycle_hooks : Array[LifecycleHook]
} derive(Eq, 
Debug)

#
LaunchPlan::capabilities

source
fn LaunchPlan::capabilities(self : LaunchPlan) -> Array[Capability]

#
LaunchPlan::capability_count

source
fn LaunchPlan::capability_count(self : LaunchPlan) -> Int

#
LaunchPlan::command_routes

source
fn LaunchPlan::command_routes(self : LaunchPlan) -> Array[String]

#
LaunchPlan::lifecycle_hooks

source
fn LaunchPlan::lifecycle_hooks(self : LaunchPlan) -> Array[LifecycleHook]

#
LaunchPlan::plugin_count

source
fn LaunchPlan::plugin_count(self : LaunchPlan) -> Int

#
LaunchPlan::plugins

source
fn LaunchPlan::plugins(self : LaunchPlan) -> Array[Plugin]

#
LaunchPlan::startup

source
fn LaunchPlan::startup(self : LaunchPlan) -> Cmd

#
LaunchPlan::window_count

source
fn LaunchPlan::window_count(self : LaunchPlan) -> Int

#
LaunchPlan::windows

source
fn LaunchPlan::windows(self : LaunchPlan) -> Array[WindowConfig]

#
LepusaMoonSuiteProductHome

source
pub(all) struct LepusaMoonSuiteProductHome {
  product_id : String
  state_path : String
  service_path : String
  runtime_path : String
  update_metadata_path : String
  tmp_path : String
} derive(Eq, ToJson, 
Debug, 
FromJson)

#
LifecycleEvent

source
pub(all) enum LifecycleEvent {
  AppStarted
  AppWillExit
  PluginSetup(String)
  PluginReady(String)
  PluginWillExit(String)
  WindowCloseRequested(String)
  WindowClosed(String)
} derive(Eq, 
Debug)

#
LifecycleEvent::app_started

source
fn LifecycleEvent::app_started() -> LifecycleEvent

#
LifecycleEvent::app_will_exit

source
fn LifecycleEvent::app_will_exit() -> LifecycleEvent

#
LifecycleEvent::plugin_ready

source
fn LifecycleEvent::plugin_ready(name : String) -> LifecycleEvent

#
LifecycleEvent::plugin_setup

source
fn LifecycleEvent::plugin_setup(name : String) -> LifecycleEvent

#
LifecycleEvent::plugin_will_exit

source
fn LifecycleEvent::plugin_will_exit(name : String) -> LifecycleEvent

#
LifecycleEvent::to_json

source
fn LifecycleEvent::to_json(self : LifecycleEvent) -> String

#
LifecycleEvent::window_close_requested

source
fn LifecycleEvent::window_close_requested(label : String) -> LifecycleEvent

#
LifecycleEvent::window_closed

source
fn LifecycleEvent::window_closed(label : String) -> LifecycleEvent

#
LifecycleHook

source
pub struct LifecycleHook {
  event : LifecycleEvent
  command : Cmd
} derive(Eq, 
Debug)

#
LifecycleHook::command

source
fn LifecycleHook::command(self : LifecycleHook) -> Cmd

#
LifecycleHook::event

source

#
LifecycleHook::new

source
fn LifecycleHook::new(event : LifecycleEvent, command : Cmd) -> LifecycleHook

#
LocalService

source
pub struct LocalService {
  name : String
  command : Array[String]
  readiness_url : String
} derive(Eq, 
Debug)

#
LocalService::command

source
fn LocalService::command(self : LocalService) -> Array[String]

#
LocalService::name

source
fn LocalService::name(self : LocalService) -> String

#
LocalService::new

source
fn LocalService::new(name~ : String, command~ : Array[String], readiness_url~ : String) -> LocalService

#
LocalService::readiness_url

source
fn LocalService::readiness_url(self : LocalService) -> String

#
LocalService::to_json

source
fn LocalService::to_json(self : LocalService) -> String

#
LocalService::validate

source
fn LocalService::validate(self : LocalService) -> Array[String]

#
LocalServiceSupervisorAction

source
pub(all) enum LocalServiceSupervisorAction {
  StartLocalService(LocalService)
  WaitLocalServiceReady(LocalService)
  StopLocalService(LocalService)
} derive(Eq, 
Debug)

#
LocalServiceSupervisorAction::kind

source

#
LocalServiceSupervisorAction::service

source

#
LocalServiceSupervisorAction::to_json

source

#
LocalServiceSupervisorPlan

source
pub struct LocalServiceSupervisorPlan {
  services : Array[LocalService]
  startup_services : Array[LocalService]
  startup_actions : Array[LocalServiceSupervisorAction]
  shutdown_actions : Array[LocalServiceSupervisorAction]
} derive(Eq, 
Debug)

#
LocalServiceSupervisorPlan::new

source

#
LocalServiceSupervisorPlan::requires_supervisor

source
fn LocalServiceSupervisorPlan::requires_supervisor(self : LocalServiceSupervisorPlan) -> Bool

#
LocalServiceSupervisorPlan::services

source

#
LocalServiceSupervisorPlan::shutdown_actions

source

#
LocalServiceSupervisorPlan::start_order

source

#
LocalServiceSupervisorPlan::startup_actions

source

#
LocalServiceSupervisorPlan::startup_services

source

#
LocalServiceSupervisorPlan::to_json

source

#
LocalServiceSupervisorPlan::validate

source

#
LocalhostSource

source
pub struct LocalhostSource {
  host : String
  port : Int
  path : String
  readiness_path : String?
  command : Array[String]
} derive(Eq, 
Debug)

#
LocalhostSource::command

source
fn LocalhostSource::command(self : LocalhostSource) -> Array[String]

#
LocalhostSource::host

source
fn LocalhostSource::host(self : LocalhostSource) -> String

#
LocalhostSource::local_service

source
fn LocalhostSource::local_service(self : LocalhostSource, name : String) -> LocalService?

#
LocalhostSource::new

source
fn LocalhostSource::new(port~ : Int, host? : String, path? : String, readiness_path? : String, command? : Array[String]) -> LocalhostSource

#
LocalhostSource::path

source
fn LocalhostSource::path(self : LocalhostSource) -> String

#
LocalhostSource::port

source
fn LocalhostSource::port(self : LocalhostSource) -> Int

#
LocalhostSource::readiness_path

source
fn LocalhostSource::readiness_path(self : LocalhostSource) -> String?

#
LocalhostSource::readiness_url

source
fn LocalhostSource::readiness_url(self : LocalhostSource) -> String

#
LocalhostSource::url

source
fn LocalhostSource::url(self : LocalhostSource) -> String

#
LocalhostSource::validate

source
fn LocalhostSource::validate(self : LocalhostSource) -> Array[String]

#
OperationScope

source
pub struct OperationScope {
  kind : OperationScopeKind
  value : String
  writable : Bool
} derive(Eq, 
Debug)

#
OperationScope::allows

source
fn OperationScope::allows(self : OperationScope, requested : OperationScope) -> Bool

#
OperationScope::command

source
fn OperationScope::command(self : OperationScope) -> String

#
OperationScope::kind

source

#
OperationScope::origin

source
fn OperationScope::origin(self : OperationScope) -> String

#
OperationScope::path

source
fn OperationScope::path(root~ : String, writable? : Bool) -> OperationScope

#
OperationScope::root

source
fn OperationScope::root(self : OperationScope) -> String

#
OperationScope::shell

source
fn OperationScope::shell(command : String) -> OperationScope

#
OperationScope::to_json

source
fn OperationScope::to_json(self : OperationScope) -> String

#
OperationScope::url

source
fn OperationScope::url(origin : String) -> OperationScope

#
OperationScope::validate

source
fn OperationScope::validate(self : OperationScope) -> Array[String]

#
OperationScope::value

source
fn OperationScope::value(self : OperationScope) -> String

#
OperationScope::writable

source
fn OperationScope::writable(self : OperationScope) -> Bool

#
OperationScopeKind

source
pub(all) enum OperationScopeKind {
  PathOperation
  ShellOperation
  UrlOperation
} derive(Eq, 
Debug)

#
OperationScopeKind::name

source
fn OperationScopeKind::name(self : OperationScopeKind) -> String

#
ParsedLaunchAssetUrl

source
type ParsedLaunchAssetUrl derive(Eq, 
Debug)

#
Permission

source
pub(all) enum Permission {
  App
  FileSystemRead
  FileSystemWrite
  FileDialog
  Network
  Localhost
  DeepLink
  SingleInstance
  Menu
  Tray
  AutoLaunch
  Window
  WindowState
  Updater
  ServiceDiscovery
  Shell
  Opener
  Dialog
  Clipboard
  Notification
  ProcessInfo
  ProcessEnvironment
  ProcessControl
  Custom(String)
} derive(Eq, 
Debug)

#
Permission::command

source
fn Permission::command(route : String) -> Permission

#
Permission::name

source
fn Permission::name(self : Permission) -> String

#
Permission::named

source
fn Permission::named(name : String) -> Result[Permission, String]

#
PermissionManifest

source
pub struct PermissionManifest {
  permissions : Array[PermissionManifestPermission]
} derive(Eq, 
Debug)

#
PermissionManifest::denied_routes

source
fn PermissionManifest::denied_routes(self : PermissionManifest) -> Array[String]

#
PermissionManifest::from_command_manifest

source
fn PermissionManifest::from_command_manifest(manifest : CommandManifest, capabilities~ : Array[Capability]) -> PermissionManifest

#
PermissionManifest::from_plugins

source
fn PermissionManifest::from_plugins(plugins~ : Array[Plugin], capabilities~ : Array[Capability], windows~ : Array[ResolvedWindow], platform? : String) -> PermissionManifest

#
PermissionManifest::new

source

#
PermissionManifest::permission

source
fn PermissionManifest::permission(self : PermissionManifest, name : String) -> PermissionManifestPermission?

#
PermissionManifest::permission_names

source
fn PermissionManifest::permission_names(self : PermissionManifest) -> Array[String]

#
PermissionManifest::permissions

source

#
PermissionManifest::to_json

source
fn PermissionManifest::to_json(self : PermissionManifest) -> String

#
PermissionManifestCommand

source
pub struct PermissionManifestCommand {
  plugin : String
  command : String
  route : String
  mode : CommandMode
  affinity : CommandExecutionAffinity
  allowed_windows : Array[String]
  allowed_origins : Array[String]
  allowed_platforms : Array[String]
} derive(Eq, 
Debug)

#
PermissionManifestCommand::affinity

source

#
PermissionManifestCommand::allowed_origins

source
fn PermissionManifestCommand::allowed_origins(self : PermissionManifestCommand) -> Array[String]

#
PermissionManifestCommand::allowed_platforms

source
fn PermissionManifestCommand::allowed_platforms(self : PermissionManifestCommand) -> Array[String]

#
PermissionManifestCommand::allowed_windows

source
fn PermissionManifestCommand::allowed_windows(self : PermissionManifestCommand) -> Array[String]

#
PermissionManifestCommand::command

source

#
PermissionManifestCommand::mode

source

#
PermissionManifestCommand::plugin

source

#
PermissionManifestCommand::route

source

#
PermissionManifestCommand::to_json

source

#
PermissionManifestGrant

source
pub struct PermissionManifestGrant {
  capability : String
  windows : Array[String]
  origins : Array[String]
  platforms : Array[String]
  operation_scopes : Array[OperationScope]
} derive(Eq, 
Debug)

#
PermissionManifestGrant::capability

source
fn PermissionManifestGrant::capability(self : PermissionManifestGrant) -> String

#
PermissionManifestGrant::operation_scopes

source

#
PermissionManifestGrant::origins

source

#
PermissionManifestGrant::platforms

source
fn PermissionManifestGrant::platforms(self : PermissionManifestGrant) -> Array[String]

#
PermissionManifestGrant::to_json

source
fn PermissionManifestGrant::to_json(self : PermissionManifestGrant) -> String

#
PermissionManifestGrant::windows

source

#
PermissionManifestPermission

source
pub struct PermissionManifestPermission {
  name : String
  commands : Array[PermissionManifestCommand]
  grants : Array[PermissionManifestGrant]
  allowed_windows : Array[String]
  allowed_origins : Array[String]
  allowed_platforms : Array[String]
  denied_routes : Array[String]
} derive(Eq, 
Debug)

#
PermissionManifestPermission::allowed_origins

source
fn PermissionManifestPermission::allowed_origins(self : PermissionManifestPermission) -> Array[String]

#
PermissionManifestPermission::allowed_platforms

source
fn PermissionManifestPermission::allowed_platforms(self : PermissionManifestPermission) -> Array[String]

#
PermissionManifestPermission::allowed_windows

source
fn PermissionManifestPermission::allowed_windows(self : PermissionManifestPermission) -> Array[String]

#
PermissionManifestPermission::commands

source

#
PermissionManifestPermission::denied_routes

source

#
PermissionManifestPermission::grants

source

#
PermissionManifestPermission::name

source

#
PermissionManifestPermission::to_json

source

#
Plugin

source
pub struct Plugin {
  name : String
  commands : Array[CommandSpec]
  lifecycle_hooks : Array[LifecycleHook]
} derive(Eq, 
Debug)

#
Plugin::command

source
fn Plugin::command(self : Plugin, name : String, mode? : CommandMode, affinity? : CommandExecutionAffinity, permission? : Permission, request? : IpcSchema, response? : IpcSchema) -> Plugin

#
Plugin::command_async

source
fn Plugin::command_async(self : Plugin, name : String, permission? : Permission, request? : IpcSchema, response? : IpcSchema, affinity? : CommandExecutionAffinity) -> Plugin

#
Plugin::command_event

source
fn Plugin::command_event(self : Plugin, name : String, permission? : Permission, request? : IpcSchema, response? : IpcSchema, affinity? : CommandExecutionAffinity) -> Plugin

#
Plugin::command_names

source
fn Plugin::command_names(self : Plugin) -> Array[String]

#
Plugin::command_routes

source
fn Plugin::command_routes(self : Plugin) -> Array[String]

#
Plugin::command_stream

source
fn Plugin::command_stream(self : Plugin, name : String, permission? : Permission, request? : IpcSchema, response? : IpcSchema, affinity? : CommandExecutionAffinity) -> Plugin

#
Plugin::command_sync

source
fn Plugin::command_sync(self : Plugin, name : String, permission? : Permission, request? : IpcSchema, response? : IpcSchema, affinity? : CommandExecutionAffinity) -> Plugin

#
Plugin::commands

source
fn Plugin::commands(self : Plugin) -> Array[CommandSpec]

#
Plugin::contract

source
fn Plugin::contract(self : Plugin) -> PluginContract

#
Plugin::lifecycle_hooks

source
fn Plugin::lifecycle_hooks(self : Plugin) -> Array[LifecycleHook]

#
Plugin::name

source
fn Plugin::name(self : Plugin) -> String

#
Plugin::new

source
fn Plugin::new(name : String) -> Plugin

#
Plugin::on_ready

source
fn Plugin::on_ready(self : Plugin, command : Cmd) -> Plugin

#
Plugin::on_setup

source
fn Plugin::on_setup(self : Plugin, command : Cmd) -> Plugin

#
Plugin::on_will_exit

source
fn Plugin::on_will_exit(self : Plugin, command : Cmd) -> Plugin

#
Plugin::validate

source
fn Plugin::validate(self : Plugin) -> Array[String]

#
Plugin::with_lifecycle

source
fn Plugin::with_lifecycle(self : Plugin, event : LifecycleEvent, command : Cmd) -> Plugin

#
PluginCommandContract

source
pub struct PluginCommandContract {
  plugin : String
  name : String
  route : String
  mode : CommandMode
  affinity : CommandExecutionAffinity
  permission : Permission
  request_schema : IpcSchema
  response_schema : IpcSchema
} derive(Eq, 
Debug)

#
PluginCommandContract::affinity

source

#
PluginCommandContract::from_command

source
fn PluginCommandContract::from_command(plugin_name~ : String, command : CommandSpec) -> PluginCommandContract

#
PluginCommandContract::mode

source

#
PluginCommandContract::name

source
fn PluginCommandContract::name(self : PluginCommandContract) -> String

#
PluginCommandContract::permission

source

#
PluginCommandContract::plugin

source
fn PluginCommandContract::plugin(self : PluginCommandContract) -> String

#
PluginCommandContract::request_schema

source

#
PluginCommandContract::response_schema

source

#
PluginCommandContract::route

source
fn PluginCommandContract::route(self : PluginCommandContract) -> String

#
PluginCommandContract::to_json

source
fn PluginCommandContract::to_json(self : PluginCommandContract) -> String

#
PluginContract

source
pub struct PluginContract {
  name : String
  commands : Array[PluginCommandContract]
  lifecycle_hooks : Array[PluginLifecycleContract]
  permissions : Array[String]
  problems : Array[String]
} derive(Eq, 
Debug)

#
PluginContract::any_thread_count

source
fn PluginContract::any_thread_count(self : PluginContract) -> Int

#
PluginContract::async_count

source
fn PluginContract::async_count(self : PluginContract) -> Int

#
PluginContract::command_count

source
fn PluginContract::command_count(self : PluginContract) -> Int

#
PluginContract::command_count_by_affinity

source
fn PluginContract::command_count_by_affinity(self : PluginContract, affinity : CommandExecutionAffinity) -> Int

#
PluginContract::command_count_by_mode

source
fn PluginContract::command_count_by_mode(self : PluginContract, mode : CommandMode) -> Int

#
PluginContract::command_routes

source
fn PluginContract::command_routes(self : PluginContract) -> Array[String]

#
PluginContract::commands

source

#
PluginContract::event_count

source
fn PluginContract::event_count(self : PluginContract) -> Int

#
PluginContract::lifecycle_count

source
fn PluginContract::lifecycle_count(self : PluginContract) -> Int

#
PluginContract::lifecycle_hooks

source

#
PluginContract::main_thread_count

source
fn PluginContract::main_thread_count(self : PluginContract) -> Int

#
PluginContract::name

source
fn PluginContract::name(self : PluginContract) -> String

#
PluginContract::ok

source
fn PluginContract::ok(self : PluginContract) -> Bool

#
PluginContract::permissions

source
fn PluginContract::permissions(self : PluginContract) -> Array[String]

#
PluginContract::problems

source
fn PluginContract::problems(self : PluginContract) -> Array[String]

#
PluginContract::stream_count

source
fn PluginContract::stream_count(self : PluginContract) -> Int

#
PluginContract::sync_count

source
fn PluginContract::sync_count(self : PluginContract) -> Int

#
PluginContract::to_json

source
fn PluginContract::to_json(self : PluginContract) -> String

#
PluginContract::worker_thread_count

source
fn PluginContract::worker_thread_count(self : PluginContract) -> Int

#
PluginLifecycleContract

source
pub struct PluginLifecycleContract {
  event : LifecycleEvent
  command_empty : Bool
} derive(Eq, 
Debug)

#
PluginLifecycleContract::command_empty

source
fn PluginLifecycleContract::command_empty(self : PluginLifecycleContract) -> Bool

#
PluginLifecycleContract::event

source

#
PluginLifecycleContract::from_hook

source

#
PluginLifecycleContract::to_json

source
fn PluginLifecycleContract::to_json(self : PluginLifecycleContract) -> String

#
ProjectManifest

source
pub struct ProjectManifest {
  metadata : AppMetadata
  windows : Array[WindowConfig]
  plugins : Array[Plugin]
  capabilities : Array[Capability]
  filesystem_scopes : Array[FileSystemScope]
  startup : Cmd
  lifecycle_hooks : Array[LifecycleHook]
  runtime : RuntimeConfig
  icon_path : String?
  resource_sources : Array[BundleResourceSource]
  runtime_dependency_sources : Array[BundleRuntimeDependencySource]
  signing : SigningConfig
} derive(Eq, 
Debug)

#
ProjectManifest::app

source
fn ProjectManifest::app(self : ProjectManifest, root : Cell) -> App

#
ProjectManifest::bundle_plan

source
fn ProjectManifest::bundle_plan(self : ProjectManifest, root : Cell, target? : BundleTarget, registered_routes? : Array[String]) -> Result[BundlePlan, Array[String]]

#
ProjectManifest::capabilities

source
fn ProjectManifest::capabilities(self : ProjectManifest) -> Array[Capability]

#
ProjectManifest::file_system_scopes

source
fn ProjectManifest::file_system_scopes(self : ProjectManifest) -> Array[FileSystemScope]

#
ProjectManifest::icon_path

source
fn ProjectManifest::icon_path(self : ProjectManifest) -> String?

#
ProjectManifest::launch_plan

source
fn ProjectManifest::launch_plan(self : ProjectManifest, root : Cell) -> Result[LaunchPlan, Array[String]]

#
ProjectManifest::lifecycle_hooks

source
fn ProjectManifest::lifecycle_hooks(self : ProjectManifest) -> Array[LifecycleHook]

#
ProjectManifest::metadata

source

#
ProjectManifest::new

source
fn ProjectManifest::new(metadata : AppMetadata, windows? : Array[WindowConfig], plugins? : Array[Plugin], capabilities? : Array[Capability], filesystem_scopes? : Array[FileSystemScope], startup? : Cmd, lifecycle_hooks? : Array[LifecycleHook], runtime? : RuntimeConfig, icon_path? : String, resource_sources? : Array[BundleResourceSource], runtime_dependency_sources? : Array[BundleRuntimeDependencySource], signing? : SigningConfig) -> ProjectManifest

#
ProjectManifest::plugins

source

#
ProjectManifest::resource_sources

source

#
ProjectManifest::runtime

source

#
ProjectManifest::runtime_dependency_sources

source
fn ProjectManifest::runtime_dependency_sources(self : ProjectManifest) -> Array[BundleRuntimeDependencySource]

#
ProjectManifest::runtime_plan

source
fn ProjectManifest::runtime_plan(self : ProjectManifest, root : Cell) -> Result[RuntimePlan, Array[String]]

#
ProjectManifest::signing

source

#
ProjectManifest::validate

source
fn ProjectManifest::validate(self : ProjectManifest) -> Array[String]

#
ProjectManifest::windows

source

#
ProjectManifest::with_capability

source
fn ProjectManifest::with_capability(self : ProjectManifest, capability : Capability) -> ProjectManifest

#
ProjectManifest::with_file_system_scope

source
fn ProjectManifest::with_file_system_scope(self : ProjectManifest, scope : FileSystemScope) -> ProjectManifest

#
ProjectManifest::with_icon_path

source
fn ProjectManifest::with_icon_path(self : ProjectManifest, icon_path : String) -> ProjectManifest

#
ProjectManifest::with_lifecycle

source
fn ProjectManifest::with_lifecycle(self : ProjectManifest, event : LifecycleEvent, command : Cmd) -> ProjectManifest

#
ProjectManifest::with_plugin

source
fn ProjectManifest::with_plugin(self : ProjectManifest, plugin : Plugin) -> ProjectManifest

#
ProjectManifest::with_resource_source

source
fn ProjectManifest::with_resource_source(self : ProjectManifest, source : BundleResourceSource) -> ProjectManifest

#
ProjectManifest::with_runtime

source
fn ProjectManifest::with_runtime(self : ProjectManifest, runtime : RuntimeConfig) -> ProjectManifest

#
ProjectManifest::with_runtime_dependency_source

source
fn ProjectManifest::with_runtime_dependency_source(self : ProjectManifest, source : BundleRuntimeDependencySource) -> ProjectManifest

#
ProjectManifest::with_signing

source
fn ProjectManifest::with_signing(self : ProjectManifest, signing : SigningConfig) -> ProjectManifest

#
ProjectManifest::with_startup

source
fn ProjectManifest::with_startup(self : ProjectManifest, startup : Cmd) -> ProjectManifest

#
ProjectManifest::with_window

source
fn ProjectManifest::with_window(self : ProjectManifest, window : WindowConfig) -> ProjectManifest

#
ProtocolMapping

source
pub struct ProtocolMapping {
  scheme : String
  root : String
} derive(Eq, 
Debug)

#
ProtocolMapping::new

source
fn ProtocolMapping::new(scheme~ : String, root~ : String) -> ProtocolMapping

#
ProtocolMapping::root

source
fn ProtocolMapping::root(self : ProtocolMapping) -> String

#
ProtocolMapping::scheme

source
fn ProtocolMapping::scheme(self : ProtocolMapping) -> String

#
RegisteredCommand

source
pub struct RegisteredCommand {
  route : String
  permission : Permission
  operation_scope : (InvokeRequest) -> Result[OperationScope, String]?
  handler : RegisteredCommandHandler
}

#
RegisteredCommand::mode

source

#
RegisteredCommand::new

source
fn RegisteredCommand::new(route : String, permission? : Permission, operation_scope? : (InvokeRequest) -> Result[OperationScope, String], handler~ : (String) -> Result[String, String]) -> RegisteredCommand

#
RegisteredCommand::new_async

source
fn RegisteredCommand::new_async(route : String, permission? : Permission, operation_scope? : (InvokeRequest) -> Result[OperationScope, String], handler~ : async (String) -> Result[String, String]) -> RegisteredCommand

#
RegisteredCommand::new_stream

source
fn RegisteredCommand::new_stream(route : String, permission? : Permission, operation_scope? : (InvokeRequest) -> Result[OperationScope, String], handler~ : (String, StreamSink) -> Result[Unit, String]) -> RegisteredCommand

#
RegisteredCommand::permission

source

#
RegisteredCommand::requires_operation_scope

source
fn RegisteredCommand::requires_operation_scope(self : RegisteredCommand) -> Bool

#
RegisteredCommand::resolve_operation_scope

source
fn RegisteredCommand::resolve_operation_scope(self : RegisteredCommand, request : InvokeRequest) -> Result[OperationScope?, String]

#
RegisteredCommand::route

source
fn RegisteredCommand::route(self : RegisteredCommand) -> String

#
RegisteredCommandHandler

source
type RegisteredCommandHandler

#
ReleaseReadinessReport

source
pub struct ReleaseReadinessReport {
  target : BundleTarget
  files : Int
  resources : Int
  artifacts : Int
  runtime_dependencies : Int
  required_runtime_dependencies : Int
  signing_configured : Bool
  signing_prerequisites : Int
  signing_steps : Int
  runtime_webviews : Int
  command_routes : Int
  registered_routes : Int
  native_launch_session_ready : Bool
  native_launch_session_issue : String
  issues : Array[String]
} derive(Eq, 
Debug)

#
ReleaseReadinessReport::artifacts

source
fn ReleaseReadinessReport::artifacts(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::command_routes

source
fn ReleaseReadinessReport::command_routes(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::files

source

#
ReleaseReadinessReport::issues

source

#
ReleaseReadinessReport::native_launch_session_issue

source
fn ReleaseReadinessReport::native_launch_session_issue(self : ReleaseReadinessReport) -> String

#
ReleaseReadinessReport::native_launch_session_ready

source
fn ReleaseReadinessReport::native_launch_session_ready(self : ReleaseReadinessReport) -> Bool

#
ReleaseReadinessReport::ready

source

#
ReleaseReadinessReport::registered_routes

source
fn ReleaseReadinessReport::registered_routes(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::required_runtime_dependencies

source
fn ReleaseReadinessReport::required_runtime_dependencies(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::resources

source
fn ReleaseReadinessReport::resources(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::runtime_dependencies

source
fn ReleaseReadinessReport::runtime_dependencies(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::runtime_webviews

source
fn ReleaseReadinessReport::runtime_webviews(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::signing_configured

source
fn ReleaseReadinessReport::signing_configured(self : ReleaseReadinessReport) -> Bool

#
ReleaseReadinessReport::signing_prerequisites

source
fn ReleaseReadinessReport::signing_prerequisites(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::signing_steps

source
fn ReleaseReadinessReport::signing_steps(self : ReleaseReadinessReport) -> Int

#
ReleaseReadinessReport::target

source

#
ReleaseReadinessReport::to_json

source
fn ReleaseReadinessReport::to_json(self : ReleaseReadinessReport) -> String

#
ResolvedSource

source
pub struct ResolvedSource {
  kind : ResolvedSourceKind
  url : String
  protocol_mappings : Array[ProtocolMapping]
  virtual_files : Array[VirtualFile]
  local_services : Array[LocalService]
} derive(Eq, 
Debug)

#
ResolvedSource::kind

source

#
ResolvedSource::local_services

source
fn ResolvedSource::local_services(self : ResolvedSource) -> Array[LocalService]

#
ResolvedSource::protocol_mappings

source
fn ResolvedSource::protocol_mappings(self : ResolvedSource) -> Array[ProtocolMapping]

#
ResolvedSource::url

source
fn ResolvedSource::url(self : ResolvedSource) -> String

#
ResolvedSource::virtual_files

source
fn ResolvedSource::virtual_files(self : ResolvedSource) -> Array[VirtualFile]

#
ResolvedSourceKind

source
pub(all) enum ResolvedSourceKind {
  ResolvedInlineHtml
  ResolvedLocalPath
  ResolvedPackagedAssets
  ResolvedRemoteUrl
  ResolvedLocalhost
  ResolvedRabbitaMount
} derive(Eq, 
Debug)

#
ResolvedWindow

source
pub struct ResolvedWindow {
  label : String
  title : String
  width : Int
  height : Int
  resizable : Bool
  title_bar : TitleBarStyle
  source : ResolvedSource
} derive(Eq, 
Debug)

#
ResolvedWindow::height

source
fn ResolvedWindow::height(self : ResolvedWindow) -> Int

#
ResolvedWindow::label

source
fn ResolvedWindow::label(self : ResolvedWindow) -> String

#
ResolvedWindow::resizable

source
fn ResolvedWindow::resizable(self : ResolvedWindow) -> Bool

#
ResolvedWindow::source

source

#
ResolvedWindow::title

source
fn ResolvedWindow::title(self : ResolvedWindow) -> String

#
ResolvedWindow::title_bar

source

#
ResolvedWindow::url

source
fn ResolvedWindow::url(self : ResolvedWindow) -> String

#
ResolvedWindow::width

source
fn ResolvedWindow::width(self : ResolvedWindow) -> Int

#
ResourceCleanupReport

source
pub struct ResourceCleanupReport {
  closed : Array[ResourceEntry]
  remaining : Array[ResourceEntry]
} derive(Eq, 
Debug)

#
ResourceCleanupReport::closed

source

#
ResourceCleanupReport::closed_count

source
fn ResourceCleanupReport::closed_count(self : ResourceCleanupReport) -> Int

#
ResourceCleanupReport::leak_report

source

#
ResourceCleanupReport::new

source

#
ResourceCleanupReport::ok

source

#
ResourceCleanupReport::remaining

source

#
ResourceCleanupReport::remaining_count

source
fn ResourceCleanupReport::remaining_count(self : ResourceCleanupReport) -> Int

#
ResourceCleanupReport::to_json

source
fn ResourceCleanupReport::to_json(self : ResourceCleanupReport) -> String

#
ResourceDescriptor

source
pub struct ResourceDescriptor {
  kind : String
  owner : String
  name : String
  metadata : String
} derive(Eq, 
Debug)

#
ResourceDescriptor::kind

source
fn ResourceDescriptor::kind(self : ResourceDescriptor) -> String

#
ResourceDescriptor::metadata

source
fn ResourceDescriptor::metadata(self : ResourceDescriptor) -> String

#
ResourceDescriptor::name

source
fn ResourceDescriptor::name(self : ResourceDescriptor) -> String

#
ResourceDescriptor::new

source
fn ResourceDescriptor::new(kind~ : String, owner? : String, name? : String, metadata? : String) -> ResourceDescriptor

#
ResourceDescriptor::owner

source
fn ResourceDescriptor::owner(self : ResourceDescriptor) -> String

#
ResourceDescriptor::to_json

source
fn ResourceDescriptor::to_json(self : ResourceDescriptor) -> String

#
ResourceDescriptor::validate

source
fn ResourceDescriptor::validate(self : ResourceDescriptor) -> Array[String]

#
ResourceEntry

source
pub struct ResourceEntry {
  id : String
  sequence : Int
  kind : String
  owner : String
  name : String
  metadata : String
  closed : Bool
} derive(Eq, 
Debug)

#
ResourceEntry::closed

source
fn ResourceEntry::closed(self : ResourceEntry) -> Bool

#
ResourceEntry::descriptor

source

#
ResourceEntry::handle

source

#
ResourceEntry::id

source
fn ResourceEntry::id(self : ResourceEntry) -> String

#
ResourceEntry::kind

source
fn ResourceEntry::kind(self : ResourceEntry) -> String

#
ResourceEntry::metadata

source
fn ResourceEntry::metadata(self : ResourceEntry) -> String

#
ResourceEntry::name

source
fn ResourceEntry::name(self : ResourceEntry) -> String

#
ResourceEntry::owner

source
fn ResourceEntry::owner(self : ResourceEntry) -> String

#
ResourceEntry::sequence

source
fn ResourceEntry::sequence(self : ResourceEntry) -> Int

#
ResourceEntry::to_json

source
fn ResourceEntry::to_json(self : ResourceEntry) -> String

#
ResourceHandle

source
pub struct ResourceHandle {
  id : String
  kind : String
  owner : String
  name : String
} derive(Eq, 
Debug)

#
ResourceHandle::from_entry

source
fn ResourceHandle::from_entry(entry : ResourceEntry) -> ResourceHandle

#
ResourceHandle::id

source
fn ResourceHandle::id(self : ResourceHandle) -> String

#
ResourceHandle::kind

source
fn ResourceHandle::kind(self : ResourceHandle) -> String

#
ResourceHandle::name

source
fn ResourceHandle::name(self : ResourceHandle) -> String

#
ResourceHandle::new

source
fn ResourceHandle::new(id~ : String, kind~ : String, owner? : String, name? : String) -> ResourceHandle

#
ResourceHandle::owner

source
fn ResourceHandle::owner(self : ResourceHandle) -> String

#
ResourceHandle::to_json

source
fn ResourceHandle::to_json(self : ResourceHandle) -> String

#
ResourceHandle::validate

source
fn ResourceHandle::validate(self : ResourceHandle) -> Array[String]

#
ResourceLeakReport

source
pub struct ResourceLeakReport {
  resources : Array[ResourceEntry]
} derive(Eq, 
Debug)

#
ResourceLeakReport::count

source
fn ResourceLeakReport::count(self : ResourceLeakReport) -> Int

#
ResourceLeakReport::handles

source

#
ResourceLeakReport::kinds

source
fn ResourceLeakReport::kinds(self : ResourceLeakReport) -> Array[String]

#
ResourceLeakReport::leaked

source
fn ResourceLeakReport::leaked(self : ResourceLeakReport) -> Bool

#
ResourceLeakReport::messages

source
fn ResourceLeakReport::messages(self : ResourceLeakReport) -> Array[String]

#
ResourceLeakReport::new

source

#
ResourceLeakReport::ok

source
fn ResourceLeakReport::ok(self : ResourceLeakReport) -> Bool

#
ResourceLeakReport::owners

source
fn ResourceLeakReport::owners(self : ResourceLeakReport) -> Array[String]

#
ResourceLeakReport::resources

source

#
ResourceLeakReport::to_json

source
fn ResourceLeakReport::to_json(self : ResourceLeakReport) -> String

#
ResourceTable

source
pub struct ResourceTable {
  next_sequence : Int
  id_prefix : String
  entries : Map[String, ResourceEntry]
  order : Array[String]
}

#
ResourceTable::cleanup_report

source
fn ResourceTable::cleanup_report(self : ResourceTable) -> ResourceCleanupReport

#
ResourceTable::close

source
fn ResourceTable::close(self : ResourceTable, id : String) -> Result[ResourceEntry, String]

#
ResourceTable::close_all

source

#
ResourceTable::close_handle

source
fn ResourceTable::close_handle(self : ResourceTable, handle : ResourceHandle) -> Result[ResourceEntry, String]

#
ResourceTable::close_kind

source
fn ResourceTable::close_kind(self : ResourceTable, kind : String) -> Array[ResourceEntry]

#
ResourceTable::close_owner

source
fn ResourceTable::close_owner(self : ResourceTable, owner : String) -> Array[ResourceEntry]

#
ResourceTable::contains

source
fn ResourceTable::contains(self : ResourceTable, id : String) -> Bool

#
ResourceTable::count

source
fn ResourceTable::count(self : ResourceTable) -> Int

#
ResourceTable::entries

source

#
ResourceTable::entries_by_kind

source
fn ResourceTable::entries_by_kind(self : ResourceTable, kind : String) -> Array[ResourceEntry]

#
ResourceTable::entries_by_owner

source
fn ResourceTable::entries_by_owner(self : ResourceTable, owner : String) -> Array[ResourceEntry]

#
ResourceTable::get

source
fn ResourceTable::get(self : ResourceTable, id : String) -> ResourceEntry?

#
ResourceTable::handle

source
fn ResourceTable::handle(self : ResourceTable, id : String) -> ResourceHandle?

#
ResourceTable::handles

source

#
ResourceTable::handles_by_kind

source
fn ResourceTable::handles_by_kind(self : ResourceTable, kind : String) -> Array[ResourceHandle]

#
ResourceTable::handles_by_owner

source
fn ResourceTable::handles_by_owner(self : ResourceTable, owner : String) -> Array[ResourceHandle]

#
ResourceTable::id_prefix

source
fn ResourceTable::id_prefix(self : ResourceTable) -> String

#
ResourceTable::ids

source
fn ResourceTable::ids(self : ResourceTable) -> Array[String]

#
ResourceTable::is_empty

source
fn ResourceTable::is_empty(self : ResourceTable) -> Bool

#
ResourceTable::leak_report

source

#
ResourceTable::new

source

#
ResourceTable::open

source
fn ResourceTable::open(self : ResourceTable, descriptor : ResourceDescriptor) -> Result[ResourceEntry, Array[String]]

#
ResourceTable::to_json

source
fn ResourceTable::to_json(self : ResourceTable) -> String

#
ResourceTable::with_prefix

source
fn ResourceTable::with_prefix(id_prefix : String) -> ResourceTable

#
RunReport

source
pub struct RunReport {
  target : String
  backend : String
  engine : String
  status : RunStatus
  webviews : Int
  first_window_title : String
  first_window_url : String
  load_url : String
  bridge_url : String
  local_services : Int
  service_supervisor : Bool
  service_start_order : Array[String]
  startup_operations : Int
  lifecycle_steps : Int
  executable_operations : Int
  executed_operations : Int
  skipped_operations : Int
  failed_operations : Int
  first_execution_failure : String
  bridge_sync_routes : Int
  bridge_async_routes : Int
  target_can_launch : Bool
  target_launch_blocker : String
} derive(Eq, 
Debug)

#
RunReport::backend

source
fn RunReport::backend(self : RunReport) -> String

#
RunReport::bridge_async_routes

source
fn RunReport::bridge_async_routes(self : RunReport) -> Int

#
RunReport::bridge_sync_routes

source
fn RunReport::bridge_sync_routes(self : RunReport) -> Int

#
RunReport::bridge_url

source
fn RunReport::bridge_url(self : RunReport) -> String

#
RunReport::engine

source
fn RunReport::engine(self : RunReport) -> String

#
RunReport::executable_operations

source
fn RunReport::executable_operations(self : RunReport) -> Int

#
RunReport::executed_operations

source
fn RunReport::executed_operations(self : RunReport) -> Int

#
RunReport::failed_operations

source
fn RunReport::failed_operations(self : RunReport) -> Int

#
RunReport::first_execution_failure

source
fn RunReport::first_execution_failure(self : RunReport) -> String

#
RunReport::first_window_title

source
fn RunReport::first_window_title(self : RunReport) -> String

#
RunReport::first_window_url

source
fn RunReport::first_window_url(self : RunReport) -> String

#
RunReport::lifecycle_steps

source
fn RunReport::lifecycle_steps(self : RunReport) -> Int

#
RunReport::load_url

source
fn RunReport::load_url(self : RunReport) -> String

#
RunReport::local_services

source
fn RunReport::local_services(self : RunReport) -> Int

#
RunReport::new

source
fn RunReport::new(target~ : String, backend~ : String, engine~ : String, status~ : RunStatus, webviews~ : Int, first_window_title? : String, first_window_url? : String, load_url? : String, bridge_url? : String, local_services? : Int, service_supervisor? : Bool, service_start_order? : Array[String], startup_operations? : Int, lifecycle_steps? : Int, executable_operations? : Int, executed_operations? : Int, skipped_operations? : Int, failed_operations? : Int, first_execution_failure? : String, bridge_sync_routes? : Int, bridge_async_routes? : Int, target_can_launch? : Bool, target_launch_blocker? : String) -> RunReport

#
RunReport::service_start_order

source
fn RunReport::service_start_order(self : RunReport) -> Array[String]

#
RunReport::service_supervisor

source
fn RunReport::service_supervisor(self : RunReport) -> Bool

#
RunReport::skipped_operations

source
fn RunReport::skipped_operations(self : RunReport) -> Int

#
RunReport::startup_operations

source
fn RunReport::startup_operations(self : RunReport) -> Int

#
RunReport::status

source
fn RunReport::status(self : RunReport) -> RunStatus

#
RunReport::target

source
fn RunReport::target(self : RunReport) -> String

#
RunReport::target_can_launch

source
fn RunReport::target_can_launch(self : RunReport) -> Bool

#
RunReport::target_launch_blocker

source
fn RunReport::target_launch_blocker(self : RunReport) -> String

#
RunReport::to_json

source
fn RunReport::to_json(self : RunReport) -> String

#
RunReport::webviews

source
fn RunReport::webviews(self : RunReport) -> Int

#
RunStatus

source
pub(all) enum RunStatus {
  RunPrepared
  RunLaunched
  RunFailed(String)
  RunUnsupported(String)
} derive(Eq, 
Debug)

#
RunStatus::message

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

#
RunStatus::name

source
fn RunStatus::name(self : RunStatus) -> String

#
RunStatus::to_json

source
fn RunStatus::to_json(self : RunStatus) -> String

#
RuntimeAction

source
pub(all) enum RuntimeAction {
  RuntimeEffect(String)
  RuntimeEmit(EventTarget, Event)
  RuntimeNavigate(String, ResolvedSource)
} derive(Eq, 
Debug)

#
RuntimeAction::to_json

source
fn RuntimeAction::to_json(self : RuntimeAction) -> String

#
RuntimeAudit

source
pub struct RuntimeAudit {
  command_manifest : CommandManifest
  permission_manifest : PermissionManifest
  registered_routes : Array[String]
  route_exposures : Array[RuntimeRouteExposure]
  findings : Array[RuntimeAuditFinding]
} derive(Eq, 
Debug)

#
RuntimeAudit::command_manifest

source
fn RuntimeAudit::command_manifest(self : RuntimeAudit) -> CommandManifest

#
RuntimeAudit::error_count

source
fn RuntimeAudit::error_count(self : RuntimeAudit) -> Int

#
RuntimeAudit::errors

source

#
RuntimeAudit::exposed_routes

source
fn RuntimeAudit::exposed_routes(self : RuntimeAudit) -> Array[String]

#
RuntimeAudit::findings

source

#
RuntimeAudit::findings_by_severity

source
fn RuntimeAudit::findings_by_severity(self : RuntimeAudit, severity : RuntimeAuditSeverity) -> Array[RuntimeAuditFinding]

#
RuntimeAudit::from_plan

source
fn RuntimeAudit::from_plan(plan : RuntimePlan) -> RuntimeAudit

#
RuntimeAudit::from_registered_routes

source
fn RuntimeAudit::from_registered_routes(plan : RuntimePlan, registered_routes : Array[String]) -> RuntimeAudit

#
RuntimeAudit::info_count

source
fn RuntimeAudit::info_count(self : RuntimeAudit) -> Int

#
RuntimeAudit::infos

source

#
RuntimeAudit::ok

source
fn RuntimeAudit::ok(self : RuntimeAudit) -> Bool

#
RuntimeAudit::permission_manifest

source
fn RuntimeAudit::permission_manifest(self : RuntimeAudit) -> PermissionManifest

#
RuntimeAudit::problems

source
fn RuntimeAudit::problems(self : RuntimeAudit) -> Array[String]

#
RuntimeAudit::registered_routes

source
fn RuntimeAudit::registered_routes(self : RuntimeAudit) -> Array[String]

#
RuntimeAudit::route_exposures

source
fn RuntimeAudit::route_exposures(self : RuntimeAudit) -> Array[RuntimeRouteExposure]

#
RuntimeAudit::to_json

source
fn RuntimeAudit::to_json(self : RuntimeAudit) -> String

#
RuntimeAudit::warning_count

source
fn RuntimeAudit::warning_count(self : RuntimeAudit) -> Int

#
RuntimeAudit::warnings

source

#
RuntimeAuditFinding

source
pub struct RuntimeAuditFinding {
  severity : RuntimeAuditSeverity
  kind : RuntimeAuditKind
  route : String
  message : String
} derive(Eq, 
Debug)

#
RuntimeAuditFinding::kind

source

#
RuntimeAuditFinding::message

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

#
RuntimeAuditFinding::new

source
fn RuntimeAuditFinding::new(severity~ : RuntimeAuditSeverity, kind~ : RuntimeAuditKind, route~ : String, message~ : String) -> RuntimeAuditFinding

#
RuntimeAuditFinding::route

source
fn RuntimeAuditFinding::route(self : RuntimeAuditFinding) -> String

#
RuntimeAuditFinding::severity

source

#
RuntimeAuditFinding::to_json

source
fn RuntimeAuditFinding::to_json(self : RuntimeAuditFinding) -> String

#
RuntimeAuditKind

source
pub(all) enum RuntimeAuditKind {
  RuntimeAuditDeniedCommand
  RuntimeAuditMissingHandler
  RuntimeAuditUndeclaredHandler
  RuntimeAuditOpenOrigin
} derive(Eq, 
Debug)

#
RuntimeAuditKind::name

source
fn RuntimeAuditKind::name(self : RuntimeAuditKind) -> String

#
RuntimeAuditSeverity

source
pub(all) enum RuntimeAuditSeverity {
  RuntimeAuditInfo
  RuntimeAuditWarning
  RuntimeAuditError
} derive(Eq, 
Debug)

#
RuntimeAuditSeverity::name

source
fn RuntimeAuditSeverity::name(self : RuntimeAuditSeverity) -> String

#
RuntimeBackend

source
pub(all) enum RuntimeBackend {
  SystemWebView
  Headless
} derive(Eq, 
Debug)

#
RuntimeBackend::name

source
fn RuntimeBackend::name(self : RuntimeBackend) -> String

#
RuntimeCapabilityGrant

source
pub struct RuntimeCapabilityGrant {
  name : String
  windows : Array[String]
  origins : Array[String]
  platforms : Array[String]
  permissions : Array[String]
  operation_scopes : Array[OperationScope]
} derive(Eq, 
Debug)

#
RuntimeCapabilityGrant::name

source

#
RuntimeCapabilityGrant::operation_scopes

source

#
RuntimeCapabilityGrant::origins

source
fn RuntimeCapabilityGrant::origins(self : RuntimeCapabilityGrant) -> Array[String]

#
RuntimeCapabilityGrant::permissions

source
fn RuntimeCapabilityGrant::permissions(self : RuntimeCapabilityGrant) -> Array[String]

#
RuntimeCapabilityGrant::platforms

source
fn RuntimeCapabilityGrant::platforms(self : RuntimeCapabilityGrant) -> Array[String]

#
RuntimeCapabilityGrant::windows

source
fn RuntimeCapabilityGrant::windows(self : RuntimeCapabilityGrant) -> Array[String]

#
RuntimeConfig

source
pub struct RuntimeConfig {
  backend : RuntimeBackend
  devtools : Bool
  asset_protocol : String
  platform : String
} derive(Eq, 
Debug)

#
RuntimeConfig::headless

source
fn RuntimeConfig::headless(platform? : String) -> RuntimeConfig

#
RuntimeConfig::platform

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

#
RuntimeConfig::system_webview

source
fn RuntimeConfig::system_webview(devtools? : Bool, asset_protocol? : String, platform? : String) -> RuntimeConfig

#
RuntimeConfig::validate

source
fn RuntimeConfig::validate(self : RuntimeConfig) -> Array[String]

#
RuntimeInvokeAuthorization

source
pub struct RuntimeInvokeAuthorization {
  kind : RuntimeInvokeAuthorizationKind
  route : String
  window_label : String
  origin : String
  platform : String
  permission : Permission?
  registered : Bool
  capability : String
  reason : String
} derive(Eq, 
Debug)

#
RuntimeInvokeAuthorization::allowed

source

#
RuntimeInvokeAuthorization::capability

source

#
RuntimeInvokeAuthorization::kind

source

#
RuntimeInvokeAuthorization::origin

source

#
RuntimeInvokeAuthorization::permission

source

#
RuntimeInvokeAuthorization::platform

source

#
RuntimeInvokeAuthorization::reason

source

#
RuntimeInvokeAuthorization::registered

source

#
RuntimeInvokeAuthorization::route

source

#
RuntimeInvokeAuthorization::to_json

source

#
RuntimeInvokeAuthorization::to_response

source

#
RuntimeInvokeAuthorization::window_label

source
fn RuntimeInvokeAuthorization::window_label(self : RuntimeInvokeAuthorization) -> String

#
RuntimeInvokeAuthorizationKind

source
pub(all) enum RuntimeInvokeAuthorizationKind {
  RuntimeInvokeAuthorized
  RuntimeInvokeInvalidRequest
  RuntimeInvokeUnknownCommand
  RuntimeInvokeUnregisteredCommand
  RuntimeInvokePermissionDenied
} derive(Eq, 
Debug)

#
RuntimeInvokeAuthorizationKind::name

source

#
RuntimeLaunchAsset

source
pub struct RuntimeLaunchAsset {
  url : String
  mime_type : String
  body : RuntimeLaunchAssetBody
} derive(Eq, 
Debug)

#
RuntimeLaunchAsset::body

source

#
RuntimeLaunchAsset::mime_type

source
fn RuntimeLaunchAsset::mime_type(self : RuntimeLaunchAsset) -> String

#
RuntimeLaunchAsset::url

source
fn RuntimeLaunchAsset::url(self : RuntimeLaunchAsset) -> String

#
RuntimeLaunchAssetBody

source
pub(all) enum RuntimeLaunchAssetBody {
  LaunchVirtualContent(String)
  LaunchLocalFile(String)
  LaunchPackagedFile(String)
} derive(Eq, 
Debug)

#
RuntimeLaunchManifest

source
pub struct RuntimeLaunchManifest {
  backend : String
  platform : String
  asset_protocol : String
  devtools : Bool
  bridge_url : String
  webviews : Array[RuntimeWebViewBoot]
  protocol_mappings : Array[RuntimeProtocolBinding]
  virtual_files : Array[RuntimeVirtualAsset]
  local_services : Array[LocalService]
  filesystem_scopes : Array[FileSystemScope]
  capabilities : Array[RuntimeCapabilityGrant]
  startup_actions : Array[RuntimeAction]
  lifecycle_hooks : Array[RuntimeLifecycleHook]
  command_manifest : CommandManifest
  permission_manifest : PermissionManifest
  declared_routes : Array[String]
  command_routes : Array[String]
  registered_routes : Array[String]
} derive(Eq, 
Debug)

#
RuntimeLaunchManifest::asset_protocol

source
fn RuntimeLaunchManifest::asset_protocol(self : RuntimeLaunchManifest) -> String

#
RuntimeLaunchManifest::backend

source
fn RuntimeLaunchManifest::backend(self : RuntimeLaunchManifest) -> String

#
RuntimeLaunchManifest::bridge_url

source
fn RuntimeLaunchManifest::bridge_url(self : RuntimeLaunchManifest) -> String

#
RuntimeLaunchManifest::capabilities

source

#
RuntimeLaunchManifest::command_manifest

source

#
RuntimeLaunchManifest::command_routes

source
fn RuntimeLaunchManifest::command_routes(self : RuntimeLaunchManifest) -> Array[String]

#
RuntimeLaunchManifest::declared_routes

source
fn RuntimeLaunchManifest::declared_routes(self : RuntimeLaunchManifest) -> Array[String]

#
RuntimeLaunchManifest::devtools

source
fn RuntimeLaunchManifest::devtools(self : RuntimeLaunchManifest) -> Bool

#
RuntimeLaunchManifest::file_system_scopes

source

#
RuntimeLaunchManifest::lifecycle_hooks

source

#
RuntimeLaunchManifest::local_services

source

#
RuntimeLaunchManifest::permission_manifest

source

#
RuntimeLaunchManifest::platform

source
fn RuntimeLaunchManifest::platform(self : RuntimeLaunchManifest) -> String

#
RuntimeLaunchManifest::protocol_mappings

source

#
RuntimeLaunchManifest::registered_routes

source
fn RuntimeLaunchManifest::registered_routes(self : RuntimeLaunchManifest) -> Array[String]

#
RuntimeLaunchManifest::resolve_asset

source
fn RuntimeLaunchManifest::resolve_asset(self : RuntimeLaunchManifest, url : String) -> Result[RuntimeLaunchAsset, String]

#
RuntimeLaunchManifest::startup_actions

source

#
RuntimeLaunchManifest::to_json

source
fn RuntimeLaunchManifest::to_json(self : RuntimeLaunchManifest) -> String

#
RuntimeLaunchManifest::virtual_files

source

#
RuntimeLaunchManifest::webviews

source

#
RuntimeLifecycleHook

source
pub struct RuntimeLifecycleHook {
  event : LifecycleEvent
  actions : Array[RuntimeAction]
} derive(Eq, 
Debug)

#
RuntimeLifecycleHook::actions

source

#
RuntimeLifecycleHook::event

source

#
RuntimeLifecycleHook::new

source

#
RuntimeLifecycleHook::to_json

source
fn RuntimeLifecycleHook::to_json(self : RuntimeLifecycleHook) -> String

#
RuntimePlan

source
pub struct RuntimePlan {
  app_metadata : AppMetadata?
  launch : LaunchPlan
  backend : RuntimeBackend
  devtools : Bool
  asset_protocol : String
  platform : String
  command_routes : Array[String]
  windows : Array[ResolvedWindow]
  filesystem_scopes : Array[FileSystemScope]
} derive(Eq, 
Debug)

#
RuntimePlan::actions

source
fn RuntimePlan::actions(self : RuntimePlan, command : Cmd) -> Result[Array[RuntimeAction], Array[String]]

#
RuntimePlan::app_metadata

source
fn RuntimePlan::app_metadata(self : RuntimePlan) -> AppMetadata?

#
RuntimePlan::asset_protocol

source
fn RuntimePlan::asset_protocol(self : RuntimePlan) -> String

#
RuntimePlan::audit

source
fn RuntimePlan::audit(self : RuntimePlan) -> RuntimeAudit

#
RuntimePlan::audit_with_registered_routes

source
fn RuntimePlan::audit_with_registered_routes(self : RuntimePlan, registered_routes : Array[String]) -> RuntimeAudit

#
RuntimePlan::authorize_invoke

source
fn RuntimePlan::authorize_invoke(self : RuntimePlan, request : InvokeRequest, registered_routes? : Array[String], check_registered? : Bool) -> RuntimeInvokeAuthorization

#
RuntimePlan::backend

source
fn RuntimePlan::backend(self : RuntimePlan) -> RuntimeBackend

#
RuntimePlan::bridge_script

source
fn RuntimePlan::bridge_script(self : RuntimePlan, config? : BridgeConfig) -> Result[BridgeScript, Array[String]]

#
RuntimePlan::capabilities

source
fn RuntimePlan::capabilities(self : RuntimePlan) -> Array[Capability]

#
RuntimePlan::capability_count

source
fn RuntimePlan::capability_count(self : RuntimePlan) -> Int

#
RuntimePlan::capability_report

source
fn RuntimePlan::capability_report(self : RuntimePlan) -> CapabilityCompileReport

#
RuntimePlan::command_manifest

source
fn RuntimePlan::command_manifest(self : RuntimePlan) -> CommandManifest

#
RuntimePlan::command_permission

source
fn RuntimePlan::command_permission(self : RuntimePlan, route : String) -> Permission?

#
RuntimePlan::command_routes

source
fn RuntimePlan::command_routes(self : RuntimePlan) -> Array[String]

#
RuntimePlan::command_routes_by_mode

source
fn RuntimePlan::command_routes_by_mode(self : RuntimePlan, mode : CommandMode) -> Array[String]

#
RuntimePlan::devtools

source
fn RuntimePlan::devtools(self : RuntimePlan) -> Bool

#
RuntimePlan::file_system_scopes

source
fn RuntimePlan::file_system_scopes(self : RuntimePlan) -> Array[FileSystemScope]

#
RuntimePlan::launch_manifest

source
fn RuntimePlan::launch_manifest(self : RuntimePlan, registered_routes? : Array[String], restrict_registered? : Bool) -> Result[RuntimeLaunchManifest, Array[String]]

#
RuntimePlan::lifecycle_actions

source
fn RuntimePlan::lifecycle_actions(self : RuntimePlan, event : LifecycleEvent) -> Result[Array[RuntimeAction], Array[String]]

#
RuntimePlan::lifecycle_hooks

source
fn RuntimePlan::lifecycle_hooks(self : RuntimePlan) -> Result[Array[RuntimeLifecycleHook], Array[String]]

#
RuntimePlan::permission_manifest

source
fn RuntimePlan::permission_manifest(self : RuntimePlan) -> PermissionManifest

#
RuntimePlan::platform

source
fn RuntimePlan::platform(self : RuntimePlan) -> String

#
RuntimePlan::plugin_count

source
fn RuntimePlan::plugin_count(self : RuntimePlan) -> Int

#
RuntimePlan::security_profile

source
fn RuntimePlan::security_profile(self : RuntimePlan, registered_routes? : Array[String], check_handlers? : Bool) -> SecurityProfile

#
RuntimePlan::startup_actions

source
fn RuntimePlan::startup_actions(self : RuntimePlan) -> Result[Array[RuntimeAction], Array[String]]

#
RuntimePlan::window_command_routes

source
fn RuntimePlan::window_command_routes(self : RuntimePlan, window_label : String) -> Array[String]

#
RuntimePlan::window_count

source
fn RuntimePlan::window_count(self : RuntimePlan) -> Int

#
RuntimePlan::windows

source

#
RuntimeProtocolBinding

source
pub struct RuntimeProtocolBinding {
  window_label : String
  scheme : String
  root : String
} derive(Eq, 
Debug)

#
RuntimeProtocolBinding::root

source

#
RuntimeProtocolBinding::scheme

source
fn RuntimeProtocolBinding::scheme(self : RuntimeProtocolBinding) -> String

#
RuntimeProtocolBinding::window_label

source
fn RuntimeProtocolBinding::window_label(self : RuntimeProtocolBinding) -> String

#
RuntimeRouteExposure

source
pub struct RuntimeRouteExposure {
  route : String
  mode : CommandMode
  registered : Bool
  exposed : Bool
  windows : Array[String]
  reasons : Array[String]
} derive(Eq, 
Debug)

#
RuntimeRouteExposure::exposed

source
fn RuntimeRouteExposure::exposed(self : RuntimeRouteExposure) -> Bool

#
RuntimeRouteExposure::mode

source

#
RuntimeRouteExposure::reasons

source
fn RuntimeRouteExposure::reasons(self : RuntimeRouteExposure) -> Array[String]

#
RuntimeRouteExposure::registered

source
fn RuntimeRouteExposure::registered(self : RuntimeRouteExposure) -> Bool

#
RuntimeRouteExposure::route

source
fn RuntimeRouteExposure::route(self : RuntimeRouteExposure) -> String

#
RuntimeRouteExposure::to_json

source
fn RuntimeRouteExposure::to_json(self : RuntimeRouteExposure) -> String

#
RuntimeRouteExposure::windows

source
fn RuntimeRouteExposure::windows(self : RuntimeRouteExposure) -> Array[String]

#
RuntimeVirtualAsset

source
pub struct RuntimeVirtualAsset {
  window_label : String
  path : String
  mime_type : String
  content : String
} derive(Eq, 
Debug)

#
RuntimeVirtualAsset::content

source
fn RuntimeVirtualAsset::content(self : RuntimeVirtualAsset) -> String

#
RuntimeVirtualAsset::mime_type

source
fn RuntimeVirtualAsset::mime_type(self : RuntimeVirtualAsset) -> String

#
RuntimeVirtualAsset::path

source
fn RuntimeVirtualAsset::path(self : RuntimeVirtualAsset) -> String

#
RuntimeVirtualAsset::window_label

source
fn RuntimeVirtualAsset::window_label(self : RuntimeVirtualAsset) -> String

#
RuntimeWebViewBoot

source
pub struct RuntimeWebViewBoot {
  label : String
  title : String
  url : String
  width : Int
  height : Int
  resizable : Bool
  title_bar : TitleBarStyle
  devtools : Bool
  asset_protocol : String
  bridge_global_name : String
  native_hook : String
  event_dispatch_hook : String
  allowed_routes : Array[String]
  initialization_scripts : Array[String]
} derive(Eq, 
Debug)

#
RuntimeWebViewBoot::allowed_routes

source
fn RuntimeWebViewBoot::allowed_routes(self : RuntimeWebViewBoot) -> Array[String]

#
RuntimeWebViewBoot::asset_protocol

source
fn RuntimeWebViewBoot::asset_protocol(self : RuntimeWebViewBoot) -> String

#
RuntimeWebViewBoot::bridge_global_name

source
fn RuntimeWebViewBoot::bridge_global_name(self : RuntimeWebViewBoot) -> String

#
RuntimeWebViewBoot::devtools

source
fn RuntimeWebViewBoot::devtools(self : RuntimeWebViewBoot) -> Bool

#
RuntimeWebViewBoot::event_dispatch_hook

source
fn RuntimeWebViewBoot::event_dispatch_hook(self : RuntimeWebViewBoot) -> String

#
RuntimeWebViewBoot::height

source
fn RuntimeWebViewBoot::height(self : RuntimeWebViewBoot) -> Int

#
RuntimeWebViewBoot::initialization_scripts

source
fn RuntimeWebViewBoot::initialization_scripts(self : RuntimeWebViewBoot) -> Array[String]

#
RuntimeWebViewBoot::label

source
fn RuntimeWebViewBoot::label(self : RuntimeWebViewBoot) -> String

#
RuntimeWebViewBoot::native_hook

source
fn RuntimeWebViewBoot::native_hook(self : RuntimeWebViewBoot) -> String

#
RuntimeWebViewBoot::resizable

source
fn RuntimeWebViewBoot::resizable(self : RuntimeWebViewBoot) -> Bool

#
RuntimeWebViewBoot::title

source
fn RuntimeWebViewBoot::title(self : RuntimeWebViewBoot) -> String

#
RuntimeWebViewBoot::title_bar

source

#
RuntimeWebViewBoot::url

source
fn RuntimeWebViewBoot::url(self : RuntimeWebViewBoot) -> String

#
RuntimeWebViewBoot::width

source
fn RuntimeWebViewBoot::width(self : RuntimeWebViewBoot) -> Int

#
SecurityProfile

source
pub struct SecurityProfile {
  command_manifest : CommandManifest
  permission_manifest : PermissionManifest
  capability_policy : CapabilityPolicy
  capability_report : CapabilityCompileReport
  runtime_audit : RuntimeAudit
  registered_routes : Array[String]
  check_handlers : Bool
  platform : String
} derive(Eq, 
Debug)

#
SecurityProfile::allowed_origins

source
fn SecurityProfile::allowed_origins(self : SecurityProfile, window_label~ : String, permission~ : Permission) -> Array[String]

#
SecurityProfile::allows

source
fn SecurityProfile::allows(self : SecurityProfile, window_label~ : String, permission~ : Permission, origin? : String) -> Bool

#
SecurityProfile::allows_operation

source
fn SecurityProfile::allows_operation(self : SecurityProfile, window_label~ : String, permission~ : Permission, scope~ : OperationScope, origin? : String) -> Bool

#
SecurityProfile::authorize_invoke

source
fn SecurityProfile::authorize_invoke(self : SecurityProfile, request : InvokeRequest) -> RuntimeInvokeAuthorization

#
SecurityProfile::authorize_operation

source
fn SecurityProfile::authorize_operation(self : SecurityProfile, request : InvokeRequest, scope : OperationScope) -> RuntimeInvokeAuthorization

#
SecurityProfile::capability_policy

source
fn SecurityProfile::capability_policy(self : SecurityProfile) -> CapabilityPolicy

#
SecurityProfile::capability_report

source

#
SecurityProfile::check_handlers

source
fn SecurityProfile::check_handlers(self : SecurityProfile) -> Bool

#
SecurityProfile::command_manifest

source
fn SecurityProfile::command_manifest(self : SecurityProfile) -> CommandManifest

#
SecurityProfile::denied_routes

source
fn SecurityProfile::denied_routes(self : SecurityProfile) -> Array[String]

#
SecurityProfile::error_count

source
fn SecurityProfile::error_count(self : SecurityProfile) -> Int

#
SecurityProfile::evaluate

source
fn SecurityProfile::evaluate(self : SecurityProfile, window_label~ : String, permission~ : Permission, origin? : String) -> CapabilityDecision

#
SecurityProfile::evaluate_operation

source
fn SecurityProfile::evaluate_operation(self : SecurityProfile, window_label~ : String, permission~ : Permission, scope~ : OperationScope, origin? : String) -> CapabilityDecision

#
SecurityProfile::exposed_routes

source
fn SecurityProfile::exposed_routes(self : SecurityProfile) -> Array[String]

#
SecurityProfile::from_plan

source
fn SecurityProfile::from_plan(plan : RuntimePlan, registered_routes? : Array[String], check_handlers? : Bool) -> SecurityProfile

#
SecurityProfile::info_count

source
fn SecurityProfile::info_count(self : SecurityProfile) -> Int

#
SecurityProfile::ok

source
fn SecurityProfile::ok(self : SecurityProfile) -> Bool

#
SecurityProfile::permission_manifest

source
fn SecurityProfile::permission_manifest(self : SecurityProfile) -> PermissionManifest

#
SecurityProfile::platform

source
fn SecurityProfile::platform(self : SecurityProfile) -> String

#
SecurityProfile::problems

source
fn SecurityProfile::problems(self : SecurityProfile) -> Array[String]

#
SecurityProfile::registered_routes

source
fn SecurityProfile::registered_routes(self : SecurityProfile) -> Array[String]

#
SecurityProfile::runtime_audit

source
fn SecurityProfile::runtime_audit(self : SecurityProfile) -> RuntimeAudit

#
SecurityProfile::to_json

source
fn SecurityProfile::to_json(self : SecurityProfile) -> String

#
SecurityProfile::unused_permissions

source
fn SecurityProfile::unused_permissions(self : SecurityProfile) -> Array[String]

#
SecurityProfile::warning_count

source
fn SecurityProfile::warning_count(self : SecurityProfile) -> Int

#
SigningConfig

source
pub struct SigningConfig {
  identity : String?
  team_id : String?
  entitlements_path : String?
  notarization_profile : String?
  timestamp_url : String?
} derive(Eq, 
Debug)

#
SigningConfig::configured

source
fn SigningConfig::configured(self : SigningConfig) -> Bool

#
SigningConfig::entitlements_path

source
fn SigningConfig::entitlements_path(self : SigningConfig) -> String?

#
SigningConfig::identity

source
fn SigningConfig::identity(self : SigningConfig) -> String?

#
SigningConfig::new

source
fn SigningConfig::new(identity? : String, team_id? : String, entitlements_path? : String, notarization_profile? : String, timestamp_url? : String) -> SigningConfig

#
SigningConfig::notarization_profile

source
fn SigningConfig::notarization_profile(self : SigningConfig) -> String?

#
SigningConfig::team_id

source
fn SigningConfig::team_id(self : SigningConfig) -> String?

#
SigningConfig::timestamp_url

source
fn SigningConfig::timestamp_url(self : SigningConfig) -> String?

#
SigningConfig::to_json

source
fn SigningConfig::to_json(self : SigningConfig) -> String

#
SigningConfig::validate

source
fn SigningConfig::validate(self : SigningConfig) -> Array[String]

#
SigningPrerequisite

source
pub struct SigningPrerequisite {
  kind : SigningPrerequisiteKind
  name : String
  description : String
} derive(Eq, 
Debug)

#
SigningPrerequisite::description

source
fn SigningPrerequisite::description(self : SigningPrerequisite) -> String

#
SigningPrerequisite::kind

source

#
SigningPrerequisite::name

source
fn SigningPrerequisite::name(self : SigningPrerequisite) -> String

#
SigningPrerequisite::new

source
fn SigningPrerequisite::new(kind~ : SigningPrerequisiteKind, name~ : String, description~ : String) -> SigningPrerequisite

#
SigningPrerequisite::to_json

source
fn SigningPrerequisite::to_json(self : SigningPrerequisite) -> String

#
SigningPrerequisiteKind

source
pub(all) enum SigningPrerequisiteKind {
  SigningIdentity
  SigningTool
  NotarizationTool
  RuntimeDependency
  PackageValidator
} derive(Eq, 
Debug)

#
SigningPrerequisiteKind::name

source

#
SigningStep

source
pub struct SigningStep {
  name : String
  tool : String
  arguments : Array[String]
  description : String
} derive(Eq, 
Debug)

#
SigningStep::arguments

source
fn SigningStep::arguments(self : SigningStep) -> Array[String]

#
SigningStep::description

source
fn SigningStep::description(self : SigningStep) -> String

#
SigningStep::name

source
fn SigningStep::name(self : SigningStep) -> String

#
SigningStep::new

source
fn SigningStep::new(name~ : String, tool~ : String, arguments~ : Array[String], description~ : String) -> SigningStep

#
SigningStep::to_json

source
fn SigningStep::to_json(self : SigningStep) -> String

#
SigningStep::tool

source
fn SigningStep::tool(self : SigningStep) -> String

#
Source

source
pub(all) enum Source {
  InlineHtml(String)
  LocalPath(String)
  PackagedAssets(String)
  RemoteUrl(String)
  Localhost(LocalhostSource)
  RabbitaCell(Cell)
} derive(Eq, 
Debug)

#
Source::html

source
fn Source::html(content : String) -> Source

#
Source::is_empty

source
fn Source::is_empty(self : Source) -> Bool

#
Source::local_path

source
fn Source::local_path(path : String) -> Source

#
Source::localhost

source
fn Source::localhost(port~ : Int, host? : String, path? : String, readiness_path? : String, command? : Array[String]) -> Source

#
Source::localhost_source

source
fn Source::localhost_source(source : LocalhostSource) -> Source

#
Source::packaged

source
fn Source::packaged(path : String) -> Source

#
Source::rabbita

source
fn Source::rabbita(cell : Cell) -> Source

#
Source::resolve

source
fn Source::resolve(self : Source, window_label~ : String, asset_protocol? : String) -> Result[ResolvedSource, String]

#
Source::url

source
fn Source::url(url : String) -> Source

#
StreamSink

source
pub struct StreamSink {
  route : String
  channel_id : String
  channels : ChannelTable
}

#
StreamSink::cancel

source
fn StreamSink::cancel(self : StreamSink) -> Result[ChannelMessage, String]

#
StreamSink::channel

source
fn StreamSink::channel(self : StreamSink) -> Channel?

#
StreamSink::channel_id

source
fn StreamSink::channel_id(self : StreamSink) -> String

#
StreamSink::closed

source
fn StreamSink::closed(self : StreamSink) -> Bool

#
StreamSink::end

source
fn StreamSink::end(self : StreamSink) -> Result[ChannelMessage, String]

#
StreamSink::fail

source
fn StreamSink::fail(self : StreamSink, message : String) -> Result[ChannelMessage, String]

#
StreamSink::handle

source
fn StreamSink::handle(self : StreamSink) -> ResourceHandle?

#
StreamSink::route

source
fn StreamSink::route(self : StreamSink) -> String

#
StreamSink::send

source
fn StreamSink::send(self : StreamSink, payload : String) -> Result[ChannelMessage, String]

#
StreamSink::to_json

source
fn StreamSink::to_json(self : StreamSink) -> String

#
TitleBarStyle

source
pub(all) enum TitleBarStyle {
  Native
  Transparent
  Hidden
} derive(Eq, 
Debug)

#
UpdateArtifactTrust

source
pub struct UpdateArtifactTrust {
  path : String
  sha256 : String
  signature : String?
} derive(Eq, 
Debug)

#
UpdateArtifactTrust::new

source
fn UpdateArtifactTrust::new(path~ : String, sha256~ : String, signature? : String) -> UpdateArtifactTrust

#
UpdateArtifactTrust::path

source
fn UpdateArtifactTrust::path(self : UpdateArtifactTrust) -> String

#
UpdateArtifactTrust::sha256

source
fn UpdateArtifactTrust::sha256(self : UpdateArtifactTrust) -> String

#
UpdateArtifactTrust::signature

source
fn UpdateArtifactTrust::signature(self : UpdateArtifactTrust) -> String?

#
UpdateArtifactTrust::validate

source
fn UpdateArtifactTrust::validate(self : UpdateArtifactTrust) -> Array[String]

#
UpdateManifest

source
pub struct UpdateManifest {
  identifier : String
  product_name : String
  version : String
  channel : String
  public_key : String?
  artifacts : Array[UpdateManifestArtifact]
} derive(Eq, 
Debug)

#
UpdateManifest::artifacts

source

#
UpdateManifest::channel

source
fn UpdateManifest::channel(self : UpdateManifest) -> String

#
UpdateManifest::identifier

source
fn UpdateManifest::identifier(self : UpdateManifest) -> String

#
UpdateManifest::new

source
fn UpdateManifest::new(identifier~ : String, product_name~ : String, version~ : String, channel? : String, public_key? : String, artifacts~ : Array[UpdateManifestArtifact]) -> UpdateManifest

#
UpdateManifest::parse

source
fn UpdateManifest::parse(text : String) -> Result[UpdateManifest, Array[String]]

#
UpdateManifest::product_name

source
fn UpdateManifest::product_name(self : UpdateManifest) -> String

#
UpdateManifest::public_key

source
fn UpdateManifest::public_key(self : UpdateManifest) -> String?

#
UpdateManifest::to_json

source
fn UpdateManifest::to_json(self : UpdateManifest) -> String

#
UpdateManifest::trust_report

source
fn UpdateManifest::trust_report(self : UpdateManifest) -> UpdateTrustReport

#
UpdateManifest::validate

source
fn UpdateManifest::validate(self : UpdateManifest) -> Array[String]

#
UpdateManifest::version

source
fn UpdateManifest::version(self : UpdateManifest) -> String

#
UpdateManifestArtifact

source
pub struct UpdateManifestArtifact {
  target : BundleTarget
  kind : BundleArtifactKind
  path : String
  url : String
  sha256 : String
  signature : String?
} derive(Eq, 
Debug)

#
UpdateManifestArtifact::kind

source

#
UpdateManifestArtifact::new

source
fn UpdateManifestArtifact::new(target~ : BundleTarget, kind~ : BundleArtifactKind, path~ : String, url~ : String, sha256~ : String, signature? : String) -> UpdateManifestArtifact

#
UpdateManifestArtifact::path

source

#
UpdateManifestArtifact::sha256

source
fn UpdateManifestArtifact::sha256(self : UpdateManifestArtifact) -> String

#
UpdateManifestArtifact::signature

source
fn UpdateManifestArtifact::signature(self : UpdateManifestArtifact) -> String?

#
UpdateManifestArtifact::target

source

#
UpdateManifestArtifact::to_json

source
fn UpdateManifestArtifact::to_json(self : UpdateManifestArtifact) -> String

#
UpdateManifestArtifact::url

source

#
UpdateManifestArtifact::validate

source
fn UpdateManifestArtifact::validate(self : UpdateManifestArtifact, signature_required? : Bool) -> Array[String]

#
UpdateTrustReport

source
pub struct UpdateTrustReport {
  trusted : Bool
  signature_required : Bool
  artifact_count : Int
  signed_artifacts : Int
  problems : Array[String]
} derive(Eq, 
Debug)

#
UpdateTrustReport::artifact_count

source
fn UpdateTrustReport::artifact_count(self : UpdateTrustReport) -> Int

#
UpdateTrustReport::problems

source
fn UpdateTrustReport::problems(self : UpdateTrustReport) -> Array[String]

#
UpdateTrustReport::signature_required

source
fn UpdateTrustReport::signature_required(self : UpdateTrustReport) -> Bool

#
UpdateTrustReport::signed_artifacts

source
fn UpdateTrustReport::signed_artifacts(self : UpdateTrustReport) -> Int

#
UpdateTrustReport::to_json

source
fn UpdateTrustReport::to_json(self : UpdateTrustReport) -> String

#
UpdateTrustReport::trusted

source
fn UpdateTrustReport::trusted(self : UpdateTrustReport) -> Bool

#
VirtualFile

source
pub struct VirtualFile {
  path : String
  content : String
} derive(Eq, 
Debug)

#
VirtualFile::content

source
fn VirtualFile::content(self : VirtualFile) -> String

#
VirtualFile::new

source
fn VirtualFile::new(path~ : String, content~ : String) -> VirtualFile

#
VirtualFile::path

source
fn VirtualFile::path(self : VirtualFile) -> String

#
WindowConfig

source
pub struct WindowConfig {
  label : String
  title : String
  width : Int
  height : Int
  resizable : Bool
  title_bar : TitleBarStyle
  source : Source?
} derive(Eq, 
Debug)

#
WindowConfig::label

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

#
WindowConfig::new

source
fn WindowConfig::new(label? : String, title? : String, width? : Int, height? : Int, resizable? : Bool, title_bar? : TitleBarStyle, source? : Source) -> WindowConfig

#
WindowConfig::parse_open_payload

source
fn WindowConfig::parse_open_payload(payload : String) -> Result[WindowConfig, String]

#
WindowConfig::resolve

source
fn WindowConfig::resolve(self : WindowConfig, asset_protocol? : String) -> Result[ResolvedWindow, Array[String]]

#
WindowConfig::validate

source
fn WindowConfig::validate(self : WindowConfig) -> Array[String]

#
WindowConfig::with_source

source
fn WindowConfig::with_source(self : WindowConfig, source : Source) -> WindowConfig

#
capabilities_with_file_system_scopes

source
fn capabilities_with_file_system_scopes(capabilities~ : Array[Capability], scopes~ : Array[FileSystemScope]) -> Array[Capability]

#
cell_with_emit

source
fn[Model, Msg] cell_with_emit(model~ : Model, update~ : (Msg, Model) -> (Model, Cmd), view~ : ((Msg) -> Cmd, Model) -> Html) -> ((Msg) -> Cmd, Cell)

#
moonsuite_product_home

source
fn moonsuite_product_home() -> LepusaMoonSuiteProductHome

#
moonsuite_product_home_for_workspace_root

source
fn moonsuite_product_home_for_workspace_root(root : String) -> LepusaMoonSuiteProductHome

#
moonsuite_product_id

source
fn moonsuite_product_id() -> String

#
moonsuite_product_runtime_path

source
fn moonsuite_product_runtime_path() -> String

#
moonsuite_product_runtime_path_for_workspace_root

source
fn moonsuite_product_runtime_path_for_workspace_root(root : String) -> String

#
moonsuite_product_service_path

source
fn moonsuite_product_service_path() -> String

#
moonsuite_product_service_path_for_workspace_root

source
fn moonsuite_product_service_path_for_workspace_root(root : String) -> String

#
moonsuite_product_state_path

source
fn moonsuite_product_state_path() -> String

#
moonsuite_product_state_path_for_workspace_root

source
fn moonsuite_product_state_path_for_workspace_root(root : String) -> String

#
moonsuite_product_tmp_path

source
fn moonsuite_product_tmp_path() -> String

#
moonsuite_product_tmp_path_for_workspace_root

source
fn moonsuite_product_tmp_path_for_workspace_root(root : String) -> String

#
moonsuite_product_update_metadata_path

source
fn moonsuite_product_update_metadata_path() -> String

#
moonsuite_product_update_metadata_path_for_workspace_root

source
fn moonsuite_product_update_metadata_path_for_workspace_root(root : String) -> String

#
new

source
fn new(root : Cell) -> App

#
none

source
let none : Cmd

#
simple_cell

source
fn simple_cell(html : Html) -> Cell

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io