@rdlabo/capacitor-native-ui 0.0.0-stage → 2.0.0-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Package.swift

@@ -0,0 +1,23 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "RdlaboCapacitorNativeUi",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(name: "RdlaboCapacitorNativeUi", targets: ["NativeUIPlugin"])
+    ],
+    dependencies: [.package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")],
+    targets: [.target(
+        name: "NativeUIPlugin",
+        dependencies: [
+            .product(name: "Capacitor", package: "capacitor-swift-pm"),
+            .product(name: "Cordova", package: "capacitor-swift-pm")
+        ],
+        path: "ios/Sources/NativeUIPlugin"
+    ), .testTarget(
+        name: "NativeUIPluginTests",
+        dependencies: ["NativeUIPlugin"],
+        path: "ios/Tests/NativeUIPluginTests"
+    )]
+)

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+# Capacitor Native UI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Render supported Web controls with UIKit and SwiftUI on iOS while keeping your application state, routing, and handlers in the WebView. Use existing Ionic markup or explicit HTML buttons; custom SwiftUI or Android Compose content can be added through experimental app-local extensions.
+
+Native UI is opt-in and currently a preview. Standard controls on Android, browsers, older iOS, and unsupported controls retain Web presentation. Android supports experimental app-local Compose extensions. Keep your application's styles and layout; the iOS theme is optional.
+
+## How projection works
+
+A **projection** is another presentation of a Web control. Your application keeps the original DOM element, state and event handlers. The plugin reads supported labels, icons, selected/disabled state and geometry, then associates the rendered control with that source element. It does not convert the page into a native screen or run a second copy of your application.
+
+| Web source                                      | Projected presentation                                                                    |
+| ----------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| Supported Ionic buttons, tabs and segments      | Native UIKit/SwiftUI controls on supported iOS                                            |
+| Explicitly marked HTML buttons and back buttons | Native buttons on supported iOS                                                           |
+| Eligible controls placed in Vertical Bars       | SwiftUI controls in the available system rail; Web rail presentation otherwise            |
+| An app-local extension's DOM element            | The SwiftUI or Compose content registered by your app, using props read from that element |
+
+The original element **stays in the DOM** while projected. Its bindings and handlers remain attached. Once native presentation is accepted, the runtime hides the source visually, prevents direct pointer interaction and hides it from Web accessibility so there are not two interactive copies. Element projection retains the source's layout box; rail spacing is supplied by your app or theme. A Web rail similarly uses its adapter's Web presentation: Ionic layout/clones or HTML proxy buttons in your `webHost`.
+
+For example, tapping a projected Save button activates the original Web button. Its existing handler performs the save and updates application state; supported DOM changes then update the projection. Tabs and other controls likewise route actions through their source adapters. Continue updating the source, rather than managing separate native state. For reader values that change without a DOM mutation, use `markForCheck()`.
+
+Projection changes presentation; it does not translate arbitrary HTML or CSS into native views. Native controls use supported data and styling; a custom Web appearance is not guaranteed to be reproduced. Removing or disabling a source prevents further valid actions. If projection is unavailable or stopped, the runtime releases its hiding state and the source returns to Web presentation, or to an available Web rail. Your application's own hidden/disabled state still applies.
+
+## Choose what to build
+
+| Goal                                                | Start here                                                                                                                          |
+| --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| Render existing Ionic controls natively             | [Ionic setup](docs/setup.md)                                                                                                        |
+| Use native buttons without Ionic                    | [HTML setup](docs/framework-independent.md)                                                                                         |
+| Add a side rail to Ionic while keeping your theme   | [Vertical Bars step by step](docs/ionic-vertical-bars.md)                                                                           |
+| Add a side rail without Ionic                       | [HTML rail setup](docs/framework-independent.md)                                                                                    |
+| Add native controls to an existing iOS 27 theme app | [Add Native UI to your theme](https://github.com/rdlabo-dev/ionic-theme-ios27/blob/main/packages/theme-ios27/docs/add-native-ui.md) |
+| Render custom SwiftUI or Android Compose content    | [App-local extensions (experimental)](docs/native-ui-extensions.md)                                                                 |
+
+## Install from npm
+
+Install in your Capacitor 8 application:
+
+```sh
+npm install @rdlabo/capacitor-native-ui
+```
+
+If you also use the iOS 27 theme, install or update both packages together:
+
+```sh
+npm install @rdlabo/capacitor-native-ui @rdlabo/ionic-theme-ios27
+```
+
+Both packages share the same release version. Declare Native UI as a direct dependency so Capacitor can discover the plugin. Theme-only apps can install just the theme; its dependency is resolved by npm and does not activate native controls.
+
+Continue with [Ionic setup](docs/setup.md), [HTML setup](docs/framework-independent.md), or [extensions](docs/native-ui-extensions.md). After configuring startup, build your application's Web assets, run `npx cap sync` and rebuild the native app. No repository checkout or archive download is needed.
+
+Upgrading from the native APIs bundled in theme 1.2.0 or 1.2.1? Follow the [migration guide](docs/migration.md) for import, configuration and native project changes.
+
+## Requirements
+
+Native startup requires Capacitor 8 and an iOS or Android project. Android extensions require API 24+ and Kotlin/Compose. Ordinary native rendering requires iOS 26+ and Xcode 26+. The Ionic adapter supports Ionic `>=8.8.1 <10`; the `/core` HTML adapter requires no Ionic or theme package. [Vertical Bars](docs/vertical-bars.md) and [extension placement](docs/native-ui-extensions.md#content-and-placement-are-independent) have additional device requirements.
+
+For standard controls, follow the setup guide for your markup; the Ionic and HTML adapters use different imports. For custom native content, start directly with the [extensions guide](docs/native-ui-extensions.md).
+
+## Reference
+
+- [Supported Ionic controls](docs/native-ui.md#supported-markup) and fallback behavior.
+- [Configuration](docs/configuration.md): defaults, selected controls, rail-only mode, and live changes.
+- [Light and dark appearance](docs/appearance.md): inherit the Web theme, configure custom HTML, and understand shared rail appearance.
+- [Vertical Bars](docs/vertical-bars.md): eligibility, appearance, and runtime API.
+- [Migration](docs/migration.md): package names, imports, and native project updates.

package/RdlaboCapacitorNativeUi.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'RdlaboCapacitorNativeUi'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.9'
+end

package/android/build.gradle

@@ -0,0 +1,69 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+}
+
+buildscript {
+    ext.kotlin_version = project.hasProperty("kotlin_version") ? rootProject.ext.kotlin_version : '2.2.20'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.kotlin:compose-compiler-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'org.jetbrains.kotlin.plugin.compose'
+
+android {
+    namespace = "dev.rdlabo.capacitor.nativeui"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    buildFeatures { compose true }
+    kotlinOptions { jvmTarget = '21' }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    api platform("androidx.compose:compose-bom:2025.10.00")
+    api "androidx.compose.ui:ui"
+    api "androidx.compose.foundation:foundation"
+    api "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    testImplementation "org.json:json:20250517"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"></manifest>

package/android/src/main/java/dev/rdlabo/capacitor/nativeui/NativeUI.kt

@@ -0,0 +1,51 @@
+package dev.rdlabo.capacitor.nativeui
+
+import android.os.Looper
+import androidx.compose.runtime.Composable
+import org.json.JSONObject
+import java.util.Collections
+
+/**
+ * App-local Compose renderers. Register on the main thread before starting the shell.
+ * Experimental API: registration interfaces and behavior may change in future releases.
+ */
+object NativeUI {
+    internal val renderers = linkedMapOf<String, (JSONObject, NativeUIActions, NativeUIContext) -> (@Composable () -> Unit)>()
+
+    fun <Props> register(
+        name: String,
+        decode: (JSONObject) -> Props,
+        content: @Composable (Props, NativeUIActions, NativeUIContext) -> Unit,
+    ) {
+        check(Looper.myLooper() == Looper.getMainLooper()) { "Register Native UI on the main thread" }
+        require(name.isNotBlank() && !renderers.containsKey(name)) { "Native UI names must be nonempty and unique" }
+        renderers[name] = { json, actions, context ->
+            val props = decode(json)
+            val view: @Composable () -> Unit = { content(props, actions, context) }
+            view
+        }
+    }
+}
+
+data class NativeUIFrame(val x: Double, val y: Double, val width: Double, val height: Double)
+
+/** Source geometry, not screen coordinates. Android currently supports element placement only. */
+data class NativeUIContext(
+    val sourceID: String,
+    val sourceFrame: NativeUIFrame,
+    val sourceFrameInDp: NativeUIFrame,
+    val viewportWidth: Double,
+    val dpPerCSSPixel: Double,
+    val dark: Boolean,
+    val rtl: Boolean,
+)
+
+/** Completion acknowledges the DOM click dispatch, not the application's asynchronous work. */
+class NativeUIActions internal constructor(names: Set<String>, private val dispatch: suspend (String) -> Unit) {
+    val availableNames: Set<String> = Collections.unmodifiableSet(names.toSet())
+    fun isAvailable(name: String): Boolean = name in availableNames
+    suspend fun activate(name: String) {
+        check(isAvailable(name)) { "Native UI action is unavailable" }
+        dispatch(name)
+    }
+}

package/android/src/main/java/dev/rdlabo/capacitor/nativeui/NativeUIPlugin.kt

@@ -0,0 +1,192 @@
+package dev.rdlabo.capacitor.nativeui
+
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import androidx.compose.ui.unit.LayoutDirection
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.util.UUID
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.math.roundToInt
+
+@CapacitorPlugin(name = "NativeUI")
+class NativeUIPlugin : Plugin() {
+    private val handler = Handler(Looper.getMainLooper())
+    private var host: FrameLayout? = null
+    private var revision = 0L
+    private var sequence = 0L
+    private var paused = false
+    private val entries = linkedMapOf<String, Entry>()
+    private val pending = mutableMapOf<String, (Boolean) -> Unit>()
+    private val layoutListener = View.OnLayoutChangeListener { _, l, t, r, b, oldL, oldT, oldR, oldB ->
+        if (l != oldL || t != oldT || r != oldR || b != oldB) {
+            host?.visibility = View.INVISIBLE
+            failActions()
+            notifyListeners("webViewMetricsChange", JSObject().put("radius", 0))
+        }
+    }
+
+    private class Entry(val view: ComposeView, var node: ExtensionNode) {
+        val content = mutableStateOf<(@Composable () -> Unit)?>(null)
+    }
+
+    override fun load() {
+        activity.runOnUiThread { bridge.webView.addOnLayoutChangeListener(layoutListener) }
+    }
+
+    @PluginMethod
+    fun configure(call: PluginCall) = onMain(call) {
+        clearViews()
+        revision = 0
+        sequence = 0
+        call.resolve(JSObject().put("supported", true).put("extensions", JSArray(NativeUI.renderers.keys.toList())))
+    }
+
+    @PluginMethod
+    fun getWebViewMetrics(call: PluginCall) = call.resolve(JSObject().put("radius", 0))
+
+    @PluginMethod
+    fun update(call: PluginCall) = onMain(call) {
+        val snapshot = NativeUISnapshot.parse(call.data)
+        require(snapshot.revision > revision) { "Stale Native UI snapshot" }
+        val web = bridge.webView
+        val parent = web.parent as? ViewGroup ?: error("WebView has no host")
+        require(web.width > 0 && web.height > 0 && web.scaleX == 1f && web.scaleY == 1f) { "WebView geometry unavailable" }
+        val scale = web.width / snapshot.viewportWidth
+        val dpScale = scale / web.resources.displayMetrics.density
+        val accepted = linkedMapOf<String, Pair<ExtensionNode, @Composable () -> Unit>>()
+        val rejected = snapshot.rejected.toMutableList()
+        for (node in snapshot.nodes) {
+            val renderer = NativeUI.renderers[node.name]
+            if (renderer == null || paused) {
+                rejected.add(node.id)
+                continue
+            }
+            try {
+                val f = node.frame
+                require(listOf(f.x * scale, f.y * scale, f.width * scale, f.height * scale).all { it in -1_000_000.0..1_000_000.0 })
+                val context = NativeUIContext(node.id, f, NativeUIFrame(f.x * dpScale, f.y * dpScale, f.width * dpScale, f.height * dpScale), snapshot.viewportWidth, dpScale, node.dark, node.rtl)
+                val actions = NativeUIActions(node.actions.keys) { action -> activate(node, action) }
+                accepted[node.id] = node to renderer(JSONObject(node.props), actions, context)
+            } catch (_: Exception) {
+                rejected.add(node.id)
+            }
+        }
+        revision = snapshot.revision
+        val container = host ?: FrameLayout(activity).also {
+            it.clipChildren = true
+            it.clipToPadding = true
+            parent.addView(it, ViewGroup.LayoutParams(web.width, web.height))
+            host = it
+        }
+        container.layoutParams = container.layoutParams.apply { width = web.width; height = web.height }
+        container.x = web.x
+        container.y = web.y
+        for (id in entries.keys.toList()) if (id !in accepted) removeEntry(id)
+        for ((id, pair) in accepted) {
+            val (node, content) = pair
+            val entry = entries[id] ?: Entry(ComposeView(activity), node).also { entry ->
+                entry.view.setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
+                container.addView(entry.view)
+                entry.view.setContent { entry.content.value?.invoke() }
+                entries[id] = entry
+            }
+            entry.node = node
+            entry.content.value = {
+                CompositionLocalProvider(LocalLayoutDirection provides if (node.rtl) LayoutDirection.Rtl else LayoutDirection.Ltr) { content() }
+            }
+            entry.view.layoutParams = FrameLayout.LayoutParams((node.frame.width * scale).roundToInt().coerceAtLeast(1), (node.frame.height * scale).roundToInt().coerceAtLeast(1)).apply {
+                leftMargin = (node.frame.x * scale).roundToInt()
+                topMargin = (node.frame.y * scale).roundToInt()
+            }
+        }
+        container.visibility = if (paused) View.INVISIBLE else View.VISIBLE
+        call.resolve(JSObject().put("revision", revision).put("rejectedControls", JSArray(rejected)))
+    }
+
+    private suspend fun activate(node: ExtensionNode, name: String): Unit = withContext(Dispatchers.Main.immediate) {
+        check(!paused && host?.visibility == View.VISIBLE && entries[node.id]?.node == node) { "Native UI action is stale" }
+        val target = node.actions[name] ?: error("Native UI action is unavailable")
+        suspendCancellableCoroutine { continuation ->
+            val request = UUID.randomUUID().toString()
+            val timeout = Runnable { pending.remove(request)?.invoke(false) }
+            pending[request] = { accepted ->
+                handler.removeCallbacks(timeout)
+                if (continuation.isActive) {
+                    if (accepted) continuation.resume(Unit)
+                    else continuation.resumeWithException(IllegalStateException("Native UI action was not accepted"))
+                }
+            }
+            continuation.invokeOnCancellation { handler.post { pending.remove(request); handler.removeCallbacks(timeout) } }
+            handler.postDelayed(timeout, 5000)
+            notifyListeners("activate", JSObject().put("revision", revision).put("id", target).put("sequence", ++sequence).put("requestId", request))
+        }
+    }
+
+    @PluginMethod
+    fun completeExtensionAction(call: PluginCall) = onMain(call) {
+        val request = call.getString("requestId") ?: error("Missing requestId")
+        pending.remove(request)?.invoke(call.getBoolean("accepted", false) == true)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun clear(call: PluginCall) = onMain(call) {
+        val next = call.data.getLong("revision")
+        require(next > revision) { "Stale Native UI clear" }
+        revision = next
+        clearViews()
+        call.resolve()
+    }
+
+    private fun onMain(call: PluginCall, block: () -> Unit) {
+        activity.runOnUiThread {
+            try { block() } catch (error: Exception) { call.reject(error.message ?: "Native UI failed", error) }
+        }
+    }
+    private fun failActions() {
+        val callbacks = pending.values.toList()
+        pending.clear()
+        callbacks.forEach { it(false) }
+    }
+    private fun removeEntry(id: String) {
+        entries.remove(id)?.let { it.view.disposeComposition(); host?.removeView(it.view) }
+    }
+    private fun clearViews() {
+        failActions()
+        entries.keys.toList().forEach(::removeEntry)
+        (host?.parent as? ViewGroup)?.removeView(host)
+        host = null
+    }
+    override fun handleOnPause() {
+        paused = true
+        host?.visibility = View.INVISIBLE
+        failActions()
+    }
+    override fun handleOnResume() {
+        paused = false
+        notifyListeners("webViewMetricsChange", JSObject().put("radius", 0))
+    }
+    override fun handleOnDestroy() {
+        bridge.webView.removeOnLayoutChangeListener(layoutListener)
+        clearViews()
+    }
+}

package/android/src/main/java/dev/rdlabo/capacitor/nativeui/NativeUISnapshot.kt

@@ -0,0 +1,57 @@
+package dev.rdlabo.capacitor.nativeui
+
+import org.json.JSONObject
+
+internal data class ExtensionNode(
+    val id: String,
+    val frame: NativeUIFrame,
+    val dark: Boolean,
+    val rtl: Boolean,
+    val name: String,
+    val props: String,
+    val actions: Map<String, String>,
+)
+
+internal data class NativeUISnapshot(val revision: Long, val viewportWidth: Double, val nodes: List<ExtensionNode>, val rejected: List<String>) {
+    companion object {
+        fun parse(json: JSONObject): NativeUISnapshot {
+            val revisionValue = json.getDouble("revision")
+            require(revisionValue.isFinite() && revisionValue >= 0 && revisionValue % 1.0 == 0.0 && revisionValue <= 9007199254740991.0)
+            val width = json.getDouble("viewportWidth")
+            require(width.isFinite() && width > 0)
+            val controls = json.getJSONArray("controls")
+            require(controls.length() <= 1000)
+            val ids = mutableSetOf<String>()
+            val nodes = mutableListOf<ExtensionNode>()
+            val rejected = mutableListOf<String>()
+            for (index in 0 until controls.length()) {
+                val item = controls.getJSONObject(index)
+                val id = item.getString("id")
+                require(id.isNotBlank() && ids.add(id))
+                if (item.getString("kind") != "extension") {
+                    rejected.add(id)
+                    continue
+                }
+                val extension = item.getJSONObject("extension")
+                if (!extension.isNull("tabBarId") || item.optString("placement") == "vertical-bars") {
+                    rejected.add(id)
+                    continue
+                }
+                val frame = NativeUIFrame(item.getDouble("x"), item.getDouble("y"), item.getDouble("width"), item.getDouble("height"))
+                require(listOf(frame.x, frame.y, frame.width, frame.height).all { it.isFinite() })
+                require(frame.width > 0 && frame.height > 0)
+                val props = extension.getString("props")
+                require(props.length <= 65536)
+                JSONObject(props)
+                val rawActions = extension.getJSONObject("actions")
+                require(rawActions.length() <= 30)
+                val actions = rawActions.keys().asSequence().associateWith { key ->
+                    require(key.isNotBlank())
+                    rawActions.getString(key).also { require(it.isNotBlank()) }
+                }
+                nodes.add(ExtensionNode(id, frame, item.optBoolean("dark"), item.optBoolean("rtl"), extension.getString("name"), props, actions))
+            }
+            return NativeUISnapshot(revisionValue.toLong(), width, nodes, rejected)
+        }
+    }
+}

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/core.d.ts

@@ -0,0 +1,4 @@
+import { NativeUIExtension, NativeUIImageReference, NativeUIReadContext, NativeUIValue, defineNativeUI } from "./native/extensions.js";
+import { ControlProjection, IonicProjectionOptions, NativeUIControls, NativeUIHandle, NativeUIOptions, NativeUIStatus, NativeUISuspension, NativeUIVerticalBarsOptions } from "./native/definitions.js";
+import { enableNativeUI } from "./native/startup.js";
+export { type ControlProjection, type IonicProjectionOptions, type NativeUIControls, type NativeUIExtension, type NativeUIHandle, type NativeUIImageReference, type NativeUIOptions, type NativeUIReadContext, type NativeUIStatus, type NativeUISuspension, type NativeUIValue, type NativeUIVerticalBarsOptions, defineNativeUI, enableNativeUI };

package/dist/core.js

@@ -0,0 +1,3 @@
+import { defineNativeUI } from "./native/extensions.js";
+import { enableNativeUI } from "./native/startup.js";
+export { defineNativeUI, enableNativeUI };

package/dist/native/activation.d.ts

@@ -0,0 +1,14 @@
+import { NativeUIExtension, NativeUIValue, defineNativeUI } from "./extensions.js";
+import { NativeUIComponent, NativeUIControls, NativeUIPlugin, NativeUIRuntimeHandle, NativeUIRuntimeOptions, NativeUIStatus, NativeUISuspension, VerticalBarEdge, WebViewMetrics } from "./definitions.js";
+//#region src/native/activation.d.ts
+interface OverlayController {
+  suspend(): Promise<() => void>;
+  destroy(): Promise<void>;
+}
+type OverlayFactory = (doc: Document, plugin: NativeUIPlugin, options: NativeUIRuntimeOptions, retain: (deferActivation?: (id: string) => boolean) => () => void, nativeRail: () => boolean) => Promise<OverlayController>;
+export declare const NativeUI: NativeUIPlugin;
+export declare const configureNativeTransition: () => Promise<WebViewMetrics>;
+export declare const enableNativeUI: (options?: NativeUIRuntimeOptions, overlayFactory?: OverlayFactory) => Promise<NativeUIRuntimeHandle>;
+//#endregion
+export { type NativeUIComponent, type NativeUIControls, type NativeUIExtension, type NativeUIRuntimeHandle, type NativeUIRuntimeOptions, type NativeUIStatus, type NativeUISuspension, type NativeUIValue, type VerticalBarEdge, type WebViewMetrics, defineNativeUI };
+//# sourceMappingURL=activation.d.ts.map

package/dist/native/activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activation.d.ts","names":[],"sources":["../../src/native/activation.ts"],"mappings":";;;UAUU;EACR,WAAW;EACX,WAAW;;KAER,kBACH,KAAK,UACL,QAAQ,gBACR,SAAS,wBACT,SAAS,mBAAmB,uCAC5B,8BACG,QAAQ;qBAkBA,UAAQ;qBAqGR,iCAAsC,QAAQ;qBAuB9C,iBAAkB,UAAS,wBAA6B,iBAAiB,mBAAiB,QAAQ"}