Struct ApplicationDefinition 

pub struct ApplicationDefinition {
    pub app_id: Cow<'static, str>,
    pub title: Cow<'static, str>,
    pub icon: IconDescriptor,
    pub record_kind: RecordKind,
    pub required: Vec<PermissionScope>,
    pub optional: Vec<PermissionScope>,
    pub opens: &'static [&'static str],
    pub workspace_record: bool,
    pub member_record: bool,
    pub opens_before_record: bool,
    pub create: fn(HostContext, LaunchTarget, RestoreInput) -> Result<AppComponent, LaunchError>,
}

Fields

app_id: Cow<'static, str>

The app’s package id. Owned: a runtime that runs installed packages (tilolang) learns it from the launch (TILO_PACKAGE_ID), not from its source. Self::app_id borrows it for as long as the definition lives.

title: Cow<'static, str>

The app’s name, as the definition’s runtime learns it.

icon: IconDescriptor

record_kind: RecordKind

required: Vec<PermissionScope>

optional: Vec<PermissionScope>

opens: &'static [&'static str]

Media types (type/subtype, lowercase) the component opens when a host hands it a file (HostContext::take_open_file); ANY_MEDIA_TYPE for a component that opens every file (a hex editor).

workspace_record: bool

The app keeps one record per workspace, the workspace’s own (a conversation everyone in the workspace shares), rather than a record per window: every window of the app in the workspace opens it, and the first creates it.

member_record: bool

The record a window opens when it names none is the person’s own record of the workspace (RecordId::of_member) rather than the workspace’s record of the app: what it keeps there (their mail) only their devices read. A person without a root identity is a member of no workspace and opens the workspace’s record as before.

opens_before_record: bool

The app’s window shows before the workspace’s record is read: a record this device holds opens off the frame, and the component takes it in when it is decoded (HostContext::record_opening). Only for an app that keeps one record per workspace.

create: fn(HostContext, LaunchTarget, RestoreInput) -> Result<AppComponent, LaunchError>

Implementations

impl ApplicationDefinition

pub fn app_id(&self) -> &str

The app’s package id, borrowed from the definition: 'static for the definitions every host keeps for the life of the process.

pub fn title(&self) -> &str

The app’s name, borrowed from the definition.

impl ApplicationDefinition

pub fn member_record_of(&self, author: &UserId) -> Option<RecordCheckout>

The record a window of author opens when it names none, when the app keeps each member’s own (Self::member_record): their own record of the workspace.

pub fn keeps_workspace_record(&self) -> bool

Whether the app keeps one record per workspace, its package primary, rather than a record per window (Self::workspace_record).

pub fn unsaved_target( &self, records: &RecordStore, ) -> Result<LaunchTarget, RecordOpenError>

The launch target of an instance with no saved record: a new record of its own, or the workspace’s record (created on first use) for an app that keeps one.

Errors

Preserves an existing record’s ownership, identity or storage failure. Only a missing primary record permits a new reservation.

pub fn opens_media_type(&self, media_type: &str) -> bool

Whether the component opens files of media_type (parameters and case ignored). ANY_MEDIA_TYPE among Self::opens opens every file.

pub fn instantiate( &self, context: HostContext, target: LaunchTarget, restore: RestoreInput, ) -> Result<AppComponent, LaunchError>

Validate, invoke the one factory under its lifetime, then restore presentation only. The factory projects through HostContext::read_record; no mutable Widget::sync or second history/autosave initialization follows its View restoration.

Errors

Ready records survive any checked validation or setup failure through ComponentSetup’s strong owner; Reserved failures cancel without publication.