Behaviour and macros for self-describing component plugins.

Plugins declare themselves declaratively, allowing Dala core to remain generic. Everything becomes a plugin: video, maps, charts, camera, ML views, custom renderers, AR, etc.

Architecture

Dala core knows almost nothing. Plugins self-describe through:

• Schema - component metadata (props, events, capabilities)
• Protocol - binary communication format (auto-generated)
• Native renderer - platform-specific implementation (iOS/Android)

This is the same pattern used by:

• React Native Fabric
• Flutter Engine
• SwiftUI internals
• Jetpack Compose runtime
• VSCode extension host
• Browser DOM

Example (top-level DSL)

defmodule MyApp.VideoPlugin do
  use Dala.Plugin

  component "video" do
    prop "source", :string
    prop "autoplay", :bool
    prop "controls", :bool
    prop "volume", :f32

    event "progress"
    event "ended"
    event "ready"

    native "ios", "DalaVideoView"
    native "android", "com.dala.video.VideoView"

    capability :gestures
    capability :accessibility
    capability :animation
  end
end

Example (plugin do block)

defmodule MyApp.VideoPlugin do
  use Dala.Plugin

  plugin do
    plugin_description "Video playback plugin"

    component "video", MyApp.VideoComponent
    plugin_event "video_zoom", MyApp.Video.Events.Zoom

    plugin_native :ios, MyApp.Video.IOS
    plugin_native :android, MyApp.Video.Android

    plugin_permission :camera
    plugin_dependency {:maps, "~> 1.0"}
    plugin_platform :ios
    plugin_platform :android
  end
end

Behaviour

Modules using Dala.Plugin must implement (or get defaults for) these callbacks:

• init(opts) → {:ok, state} | {:error, reason} — resource allocation (required)

• components() → [Component.t()] — declare components (required)
• capabilities() → [atom()] — what this plugin provides (required)
• permissions() → [atom()] — declare required permissions (optional, default [])
• native_modules(platform) → [module()] — platform-specific native modules (optional, default [])
• dependencies() → [{atom(), String.t()}] — dependency ordering (optional, default [])

• validate_config(config) → :ok | {:error, reason} — compile-time hooks (optional, default :ok)

• handle_event(event, payload, state) → {:ok, state} | {:error, reason} — runtime hooks (optional, default {:ok, state})

• cleanup(state) → :ok — resource deallocation / hot reload (optional, default :ok)

Versioning

Plugins MUST declare versions for compatibility:

schema_version "1.0.0"
protocol_version 3
native_api_version "2.0.0"

This prevents ecosystem fragmentation.

Host/Runtime Separation

Plugins should NEVER directly access:

• BEAM internals
• Scheduler state
• Raw protocol sockets

Instead:

Plugin
   ↓
Host API
   ↓
Dala Runtime

Exactly like browser extensions.

Generic Node Model

Everything becomes a generic node:

%Dala.Node{
  type: "video",
  props: %{source: "...", autoplay: true},
  children: []
}

Dala core NEVER special-cases video, maps, or charts. The same generic lifecycle applies to all plugins:

• create/2
• update/2
• layout/2
• event/3
• dispose/1

Optional capabilities:

• animate/2
• focus/2
• accessibility/2
• snapshot/1
• texture/1
• gesture/2

Universal Command Stream

Dala core emits only generic operations:

• CREATE_NODE
• UPDATE_PROP
• REMOVE_NODE
• EMIT_EVENT
• RUN_ANIMATION

Plugins interpret semantics. Core stays tiny.