🥮 mooncakes.io

    lepusa

    MoonBit-native desktop application framework research and implementation.

    desktop
    webview
    framework
    native
    Download zip
    Author
    Version
    0.1.2
    License
    Apache-2.0
    Repository
    Last updated
    3 months ago
    Downloads
    473

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

    © 2026 mooncakes.io