peachsim 0.1.659 → 0.1.661

package/kotlin/AppSources/dev/peach/app/PeachApp.kt

@@ -24,13 +24,16 @@ import androidx.compose.ui.platform.PlatformInsets
 import androidx.compose.ui.platform.PlatformWindowInsets
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.text.font.FontFamily
 import androidx.lifecycle.Lifecycle
 import androidx.navigationevent.NavigationEventDispatcher
 import androidx.navigationevent.NavigationEventDispatcherOwner
 import PeachComposeMount
 import addMount
+import mounts
 import preparePeachDevice
 import robotoFamily
 import org.json.JSONObject
@@ -45,21 +48,37 @@ internal class PeachAppSpec(
     val window: WindowTheme,
     val createApplication: () -> Application,
     val createActivity: () -> Activity,
+    // the activity's configChanges includes uiMode: it takes a night mode
+    // change in onConfigurationChanged rather than relaunching
+    val handlesUiMode: Boolean,
 )
 
-// the system bars the device delivers to the window's content, in pixels: all
-// of them on an edge-to-edge window, none once the decor fits system windows.
-private class SystemBarInsets(
-    private val window: Window,
-    private val status: Int,
-    private val navigation: Int,
-) : PlatformWindowInsets {
+// the insets the device delivers to the window's content, in pixels: all of
+// them on an edge-to-edge window, none once the decor fits system windows.
+// insets lists the status bars, navigation bars, display cutout, system
+// gestures, mandatory system gestures and tappable element, each left, top,
+// right and bottom.
+private class DeviceInsets(private val window: Window, insets: String) : PlatformWindowInsets {
+    private val pixels = insets.split(',').map { it.toInt() }.also { require(it.size == 24) }
+
     // read when compose lays out, so a later change to the window applies
-    private fun delivered(pixels: Int) = if (window.fitsSystemWindows) 0 else pixels
-    override val statusBars = PlatformInsets(getTop = { delivered(status) })
-    override val navigationBars = PlatformInsets(getBottom = { delivered(navigation) })
-    override val systemBars =
-        PlatformInsets(getTop = { delivered(status) }, getBottom = { delivered(navigation) })
+    private fun type(index: Int): PlatformInsets {
+        fun side(offset: Int) = { if (window.fitsSystemWindows) 0 else pixels[index * 4 + offset] }
+        return PlatformInsets(side(0), side(1), side(2), side(3))
+    }
+
+    override val statusBars = type(0)
+    override val navigationBars = type(1)
+    override val displayCutout = type(2)
+    override val systemGestures = type(3)
+    override val mandatorySystemGestures = type(4)
+    override val tappableElement = type(5)
+    override val systemBars = PlatformInsets(
+        { maxOf(statusBars.left, navigationBars.left) },
+        { maxOf(statusBars.top, navigationBars.top) },
+        { maxOf(statusBars.right, navigationBars.right) },
+        { maxOf(statusBars.bottom, navigationBars.bottom) },
+    )
 }
 
 private class ActivityOwners(activity: ComponentActivity) : PlatformArchitectureComponentsOwner {
@@ -71,6 +90,41 @@ private class ActivityOwners(activity: ComponentActivity) : PlatformArchitecture
     }
 }
 
+// the device and the application one started app process keeps, and what
+// ActivityThread's record holds for its one activity: whether it is paused or
+// stopped, and the state it saved when it stopped, until it resumes
+private class AppProcess(
+    val spec: PeachAppSpec,
+    val application: Application,
+    val density: Float, val fontScale: Float, val locale: String, val gpu: Boolean, val stencilBits: Int,
+    val fonts: FontFamily,
+    val insets: String,
+    val invalidate: (Boolean) -> Unit,
+) {
+    lateinit var activity: Activity
+    lateinit var mount: PeachComposeMount
+    // the window the device presents, once its scene is in place
+    var window: Window? = null
+    var mountId = 0
+    // the held view's place among its window's views; a relaunched window's
+    // first view takes the place the last window's view held, as it takes
+    // that view's saved state on the device
+    var view = 0
+    var paused = false
+    var stopped = false
+    var state: Bundle? = null
+    // the night mode last reported to the activity: ActivityRecord compares
+    // the configuration with it before a relaunch or onConfigurationChanged
+    var reportedNight = false
+}
+
+private var process: AppProcess? = null
+
+private fun nightConfiguration(night: Boolean) = Configuration().apply {
+    uiMode = Configuration.UI_MODE_TYPE_NORMAL or
+        if (night) Configuration.UI_MODE_NIGHT_YES else Configuration.UI_MODE_NIGHT_NO
+}
+
 // a cold start in ActivityThread's order: the Application and its onCreate,
 // then the launcher activity attached to its window and launcher intent,
 // onCreate, onStart, onPostCreate, onResume and onPostResume, and only then the
@@ -79,71 +133,23 @@ internal fun peachStartApp(
     spec: PeachAppSpec,
     density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,
     regular: String, medium: String, bold: String,
-    statusBar: Int, navigationBar: Int, night: Boolean,
+    insets: String, night: Boolean,
     invalidate: (Boolean) -> Unit,
 ): String {
     try {
         require(backend == "graphite" || backend == "raster")
         preparePeachDevice(locale)
-        processResources = Resources(Configuration().apply {
-            uiMode = Configuration.UI_MODE_TYPE_NORMAL or
-                if (night) Configuration.UI_MODE_NIGHT_YES else Configuration.UI_MODE_NIGHT_NO
-        })
-        val fonts = robotoFamily(regular, medium, bold)
+        processResources = Resources(nightConfiguration(night))
         val application = spec.createApplication()
         application.onCreate()
-        val activity = spec.createActivity()
-        val componentActivity = activity as? ComponentActivity
-        lateinit var window: Window
-        lateinit var mount: PeachComposeMount
-        var mountId = 0
-        // the window's one scene composes the ComposeView it holds; a new
-        // view starts a new composition, as on the device
-        var held by mutableStateOf<ComposeView?>(null)
-        val host = object : PeachWindowHost {
-            override fun compose(view: ComposeView): AutoCloseable {
-                held = view
-                return AutoCloseable { if (held === view) held = null }
-            }
-
-            override fun windowChanged() {
-                if (mountId != 0)
-                    mount.emitAtFrame("window") { window.describe().toString() }
-            }
-        }
-        window = Window(activity, spec.window, host)
-        activity.attach(
-            application,
-            spec.component,
-            Intent(Intent.ACTION_MAIN, setOf(Intent.CATEGORY_LAUNCHER), spec.launcher),
-            window,
+        val app = AppProcess(
+            spec, application, density, fontScale, locale, backend == "graphite", stencilBits,
+            robotoFamily(regular, medium, bold), insets, invalidate,
         )
-        activity.performCreate(null)
-        activity.performStart()
-        activity.performPostCreate(null)
-        activity.performResume()
-        running = activity
-        mount = PeachComposeMount(
-            density, fontScale, locale, backend == "graphite", stencilBits, fonts, invalidate,
-            owners = componentActivity?.let(::ActivityOwners),
-            insets = SystemBarInsets(window, statusBar, navigationBar),
-            clockRunning = { componentActivity == null || componentActivity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) },
-        )
-        mount.setContent {
-            val content = @Composable { held?.let { view -> key(view) { view.Content() } }; Unit }
-            // the content view's tree resolves the activity as its back dispatcher owner
-            if (componentActivity != null)
-                CompositionLocalProvider(LocalOnBackPressedDispatcherOwner provides componentActivity, content = content)
-            else content()
-        }
-        mountId = addMount(mount)
-        runningMount = mount
-        window.addToWindowManager()
-        val view = checkNotNull(held) {
-            "${spec.component.flattenToShortString()} set no ComposeView as its content; Peach composes only ComposeView content"
-        }
+        process = app
+        val view = launchActivity(app, null)
         val params = view.layoutParams
-        return window.describe().put("ok", true).put("id", mountId)
+        return app.activity.window.describe().put("ok", true).put("id", app.mountId)
             .put("wrapWidth", params?.width == ViewGroup.LayoutParams.WRAP_CONTENT)
             .put("wrapHeight", params?.height == ViewGroup.LayoutParams.WRAP_CONTENT)
             .toString()
@@ -153,9 +159,89 @@ internal fun peachStartApp(
     }
 }
 
-// the activity the app runs, once started, and the scene its window composes
-private var running: Activity? = null
-private var runningMount: PeachComposeMount? = null
+// ActivityThread's handleLaunchActivity: a new instance of the launcher
+// activity created from the state its last instance saved, if any, with what
+// that instance retained, then started, restored, resumed and its window
+// added. the window's scene takes the process's mount id, so the device keeps
+// presenting it.
+private fun launchActivity(app: AppProcess, lastNonConfigurationInstance: Any?): ComposeView {
+    val spec = app.spec
+    val activity = spec.createActivity()
+    val componentActivity = activity as? ComponentActivity
+    val state = app.state
+    lateinit var window: Window
+    lateinit var mount: PeachComposeMount
+    // the window's one scene composes the ComposeView it holds; a new
+    // view starts a new composition, as on the device. the key is the view's
+    // place, not the view, so a relaunched window's view lands on the keys its
+    // saved state was written under
+    var held by mutableStateOf<ComposeView?>(null)
+    var place by mutableIntStateOf((app.view - 1).coerceAtLeast(0))
+    val host = object : PeachWindowHost {
+        override fun compose(view: ComposeView): AutoCloseable {
+            held = view
+            place += 1
+            app.view = place
+            return AutoCloseable { if (held === view) held = null }
+        }
+
+        // a change before the window is presented reaches the device with
+        // the window itself
+        override fun windowChanged() {
+            if (app.window === window)
+                mount.emitAtFrame("window") { window.describe().toString() }
+        }
+    }
+    window = Window(activity, spec.window, host)
+    activity.attach(
+        app.application,
+        spec.component,
+        Intent(Intent.ACTION_MAIN, setOf(Intent.CATEGORY_LAUNCHER), spec.launcher),
+        window,
+        lastNonConfigurationInstance,
+    )
+    activity.performCreate(state)
+    activity.performStart()
+    if (state != null) activity.performRestoreInstanceState(state)
+    activity.performPostCreate(state)
+    activity.performResume()
+    app.activity = activity
+    app.paused = false
+    app.stopped = false
+    app.state = null
+    app.reportedNight = isNight(activity.resources.configuration)
+    mount = PeachComposeMount(
+        app.density, app.fontScale, app.locale, app.gpu, app.stencilBits, app.fonts, app.invalidate,
+        night = isNight(activity.resources.configuration),
+        owners = componentActivity?.let(::ActivityOwners),
+        insets = DeviceInsets(window, app.insets),
+        clockRunning = { componentActivity == null || componentActivity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) },
+    )
+    mount.setContent {
+        val content = @Composable { held?.let { view -> key(place) { view.Content() } }; Unit }
+        // the content view's tree resolves the activity as its back dispatcher owner
+        if (componentActivity != null)
+            CompositionLocalProvider(LocalOnBackPressedDispatcherOwner provides componentActivity, content = content)
+        else content()
+    }
+    if (app.mountId == 0) app.mountId = addMount(mount)
+    else {
+        // the relaunched window takes the device's bounds and reports its
+        // window, which the new instance may have set differently
+        mount.constraints = app.mount.constraints
+        mounts[app.mountId] = mount
+        mount.emitAtFrame("window") { window.describe().toString() }
+        app.invalidate(true)
+    }
+    app.mount = mount
+    app.window = window
+    window.addToWindowManager()
+    return checkNotNull(held) {
+        "${spec.component.flattenToShortString()} set no ComposeView as its content; Peach composes only ComposeView content"
+    }
+}
+
+private fun runningApp() = checkNotNull(process) { "the app is not running" }
 
 // the device's back: an activity with predictive back gets it through its
 // window's back dispatch, where ComponentActivity's dispatcher takes it only
@@ -163,7 +249,7 @@ private var runningMount: PeachComposeMount? = null
 // rest; without predictive back the key reaches onBackPressed. false when the
 // task moved to the back, which the device then shows as home.
 internal fun peachAppBack(predictive: Boolean): Boolean {
-    val activity = checkNotNull(running) { "the app is not running" }
+    val activity = runningApp().activity
     activity.movedTaskToBack = false
     val dispatcher = (activity as? ComponentActivity)?.onBackPressedDispatcher
     if (!predictive) activity.onBackPressed()
@@ -172,20 +258,81 @@ internal fun peachAppBack(predictive: Boolean): Boolean {
     return !activity.movedTaskToBack
 }
 
-// the task left the foreground (onPause, onStop, onSaveInstanceState) or came back to it
-// (onRestart, onStart, onResume, onPostResume), as ActivityThread drives it
+// ActivityThread's pause and stop; from API 28 an activity that stops saves
+// its state after onStop, kept for a relaunch until it resumes
+private fun pauseAndStop(app: AppProcess) {
+    if (!app.paused) {
+        app.activity.performPause()
+        app.paused = true
+    }
+    if (!app.stopped) {
+        app.activity.performStop()
+        app.stopped = true
+        app.state = Bundle().also(app.activity::performSaveInstanceState)
+    }
+}
+
+// the task left the foreground (onPause, onStop, onSaveInstanceState) or came
+// back to it (onRestart, onStart, onResume, onPostResume). a configuration
+// that changed while it was stopped reaches it first: a relaunch in place of
+// the restart, or onConfigurationChanged.
 internal fun peachAppTask(foreground: Boolean) {
-    val activity = checkNotNull(running) { "the app is not running" }
-    if (foreground) {
-        activity.performRestart()
-        activity.performResume()
-        // the frame clock runs again once the activity is started
-        checkNotNull(runningMount).invalidate(false)
-    } else {
-        activity.performPause()
-        activity.performStop()
-        // from API 28 an activity that stops saves its state after onStop;
-        // ActivityThread keeps it for a relaunch, which no path here takes yet
-        activity.performSaveInstanceState(Bundle())
+    val app = runningApp()
+    if (!foreground) return pauseAndStop(app)
+    if (reportConfiguration(app)) return
+    app.activity.performRestart()
+    app.activity.performResume()
+    app.paused = false
+    app.stopped = false
+    app.state = null
+    // the frame clock runs again once the activity is started
+    app.mount.invalidate(false)
+}
+
+// gives a visible activity the process configuration when it differs from the
+// one last reported to it: a relaunch, or onConfigurationChanged under
+// configChanges uiMode. true when it relaunched.
+private fun reportConfiguration(app: AppProcess): Boolean {
+    val configuration = processResources.configuration
+    if (isNight(configuration) == app.reportedNight) return false
+    if (!app.spec.handlesUiMode) {
+        relaunch(app)
+        return true
+    }
+    app.reportedNight = isNight(configuration)
+    app.activity.performConfigurationChanged(Configuration().apply { setTo(configuration) })
+    app.mount.night = app.reportedNight
+    return false
+}
+
+private fun isNight(configuration: Configuration) =
+    configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
+
+// the device's night mode changed. the process's configuration changes in
+// place and the Application hears it first; a visible activity then takes it.
+// a stopped activity takes it once visible again, if it still differs.
+internal fun peachAppNight(night: Boolean) {
+    val app = runningApp()
+    val configuration = processResources.configuration
+    if (isNight(configuration) == night) return
+    configuration.setTo(nightConfiguration(night))
+    app.application.onConfigurationChanged(Configuration().apply { setTo(configuration) })
+    if (!app.stopped) reportConfiguration(app)
+}
+
+// ActivityThread's handleRelaunchActivityInner: pause and stop with the state
+// saved, collect what the next instance keeps, destroy, then launch anew
+private fun relaunch(app: AppProcess) {
+    val old = app.activity
+    val oldMount = app.mount
+    old.isChangingConfigurations = true
+    pauseAndStop(app)
+    val retained = old.retainNonConfigurationInstances()
+    old.performDestroy()
+    old.window.removeFromWindowManager()
+    try {
+        launchActivity(app, retained)
+    } finally {
+        oldMount.close()
     }
 }

package/kotlin/ComposeSources/PeachComposeHost.kt

@@ -7,6 +7,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.runtime.snapshots.Snapshot
+import androidx.compose.ui.LocalSystemTheme
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.asComposeCanvas
 import androidx.compose.ui.input.InputMode
@@ -44,6 +45,7 @@ import androidx.compose.ui.unit.LayoutDirection
 import dev.onejs.one.OneNativeSourceViewDispatch
 import kotlin.io.encoding.Base64
 import kotlinx.coroutines.Dispatchers
+import org.jetbrains.skiko.SystemTheme
 import org.jetbrains.skia.BackendRenderTarget
 import org.jetbrains.skia.Bitmap
 import org.jetbrains.skia.Color
@@ -123,11 +125,14 @@ internal class PeachComposeMount(
     private val stencilBits: Int,
     private val fonts: FontFamily,
     val invalidate: (Boolean) -> Unit,
+    night: Boolean,
     owners: PlatformArchitectureComponentsOwner? = null,
     insets: PlatformWindowInsets? = null,
     private val clockRunning: () -> Boolean = { true },
 ) : AutoCloseable {
     var props by mutableStateOf("")
+    // the configuration's night mode, which isSystemInDarkTheme reads
+    var night by mutableStateOf(night)
     var constraints = Constraints()
         set(value) { if (field != value) { field = value; needsMeasure = true } }
     private val events = mutableListOf<JSONObject>()
@@ -150,7 +155,11 @@ internal class PeachComposeMount(
 
     fun setContent(content: @Composable () -> Unit) {
         try {
-            scene.setContent { PeachAndroidFonts(fonts, content) }
+            scene.setContent {
+                CompositionLocalProvider(LocalSystemTheme provides if (night) SystemTheme.DARK else SystemTheme.LIGHT) {
+                    PeachAndroidFonts(fonts, content)
+                }
+            }
         } catch (failure: Throwable) {
             close()
             throw failure
@@ -289,7 +298,7 @@ internal fun robotoFamily(regular: String, medium: String, bold: String) = FontF
 
 @JsExport
 fun peachViewMount(source: String, view: String, hash: String, props: String,
-    density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,
+    density: Float, fontScale: Float, locale: String, night: Boolean, backend: String, stencilBits: Int,
     regular: String, medium: String, bold: String, invalidate: (Boolean) -> Unit): String {
     try {
         val dispatch = peachViewDispatcher(source)
@@ -297,7 +306,7 @@ fun peachViewMount(source: String, view: String, hash: String, props: String,
             .put("error", "composable source $source changed; rebuild the app").toString()
         require(backend == "graphite" || backend == "raster")
         preparePeachDevice(locale)
-        val mount = PeachComposeMount(density, fontScale, locale, backend == "graphite", stencilBits, robotoFamily(regular, medium, bold), invalidate)
+        val mount = PeachComposeMount(density, fontScale, locale, backend == "graphite", stencilBits, robotoFamily(regular, medium, bold), invalidate, night)
         mount.props = props
         mount.setContent { dispatch.Content(view, mount.props, mount::emit) }
         return JSONObject().put("ok", true).put("id", addMount(mount)).toString()
@@ -307,6 +316,9 @@ fun peachViewMount(source: String, view: String, hash: String, props: String,
 }
 
 @JsExport fun peachViewUpdate(id: Int, props: String) { checkNotNull(mounts[id]).props = props }
+// a host activity that handles uiMode itself, as React Native's does, keeps
+// its views and hands them the new configuration
+@JsExport fun peachViewNight(id: Int, night: Boolean) { checkNotNull(mounts[id]).night = night }
 @JsExport fun peachViewConstraints(id: Int, minWidth: Int, maxWidth: Int, minHeight: Int, maxHeight: Int) {
     checkNotNull(mounts[id]).also {
         it.constraints = Constraints(minWidth, maxWidth, minHeight, maxHeight)

package/kotlin/fork/README.md

@@ -10,6 +10,7 @@ builds until upstream supplies equivalent worker and native host hooks.
 | --- | --- | --- |
 | Compose `ui` | `Actuals.wasm.kt` | clock reads `globalThis.performance.now()` |
 | Compose `ui` | `PlatformClipboard.web.kt` | worker-safe secure-context and clipboard reads |
+| Compose `ui` | `SystemTheme.kt` | `LocalSystemTheme` visible to the host, which provides the device's night mode |
 | Compose `ui-text` | `PlatformLocale.web.kt` | explicit `setPlatformLocaleProvider`; its default keeps upstream navigator behavior |
 | Skiko | `OsArch.web.kt` | explicit `setHostOsProvider`; its default lazily retains upstream OS detection |
 | Skiko | `Actuals.web.kt` | nanosecond clock reads `globalThis.performance.now()` |

package/kotlin/fork/compose-worker-globals.patch

@@ -105,3 +105,29 @@ index 7aa3e26..47e20a8 100644
  
  /**
   * https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API
+diff --git a/compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/SystemTheme.kt b/compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/SystemTheme.kt
+index a14f182..9c4862d 100644
+--- a/compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/SystemTheme.kt
++++ b/compose/ui/ui/src/skikoMain/kotlin/androidx/compose/ui/SystemTheme.kt
+@@ -12,6 +12,11 @@
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
++ *
++ * modified for Peach: the system theme composition local is visible to a
++ * native host, which provides the device's night mode to the scenes it owns,
++ * as later upstream releases expose it. see the fork record for the patch and
++ * upstream revision.
+  */
+ 
+ package androidx.compose.ui
+@@ -27,7 +32,8 @@ enum class SystemTheme {
+     Dark, Light, Unknown
+ }
+ 
+-internal val LocalSystemTheme = staticCompositionLocalOf { currentSystemTheme }
++@InternalComposeUiApi
++val LocalSystemTheme = staticCompositionLocalOf { currentSystemTheme }
+ 
+ @InternalComposeUiApi
+ @Composable

package/kotlin/fork/fork.json

@@ -18,7 +18,7 @@
       "tag": "v1.13.0-alpha01",
       "commit": "a9e47e8aa04c95cfe572ab4297c770f3cbfb234e",
       "patch": "compose-worker-globals.patch",
-      "patchSha256": "51fa45bda1e0aae7db2eab1b056def406352958257e1d3b899c5c3d8aa5edddb"
+      "patchSha256": "5c45b67b3028637e6eafa351db004f23ad50c6f00ac2b5e7738fd026ac93cef0"
     },
     {
       "name": "skiko",

package/kotlin/toolchain.json

@@ -18,9 +18,9 @@
   ],
   "composeLibraries": [
     {
-      "name": "ui-wasm-js-1.13.0-alpha01-peach-0e3c251301e0.klib",
-      "url": "https://r2.rnxsim.com/peach-kotlin-fork/0e3c251301e0df405e50d0aa7d45b401c1aa26f7ed0a7001c6ce2bc68f5d667b/ui-wasm-js-1.13.0-alpha01.klib",
-      "sha256": "0e3c251301e0df405e50d0aa7d45b401c1aa26f7ed0a7001c6ce2bc68f5d667b"
+      "name": "ui-wasm-js-1.13.0-alpha01-peach-8caddb83ba2f.klib",
+      "url": "https://r2.rnxsim.com/peach-kotlin-fork/8caddb83ba2f8dddd4c869eca936f0039d99c39c986f8af162e59eb27dbb92ed/ui-wasm-js-1.13.0-alpha01.klib",
+      "sha256": "8caddb83ba2f8dddd4c869eca936f0039d99c39c986f8af162e59eb27dbb92ed"
     },
     {
       "name": "foundation-wasm-js-1.13.0-alpha01.klib",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.659",
+  "version": "0.1.661",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -303,6 +303,7 @@
     "build:cli-binary": "bun scripts/build-cli-binary.ts",
     "smoke:cli-binary": "bun scripts/smoke-cli-binary.ts",
     "publish:cli-binary": "bun scripts/publish-cli-binaries.ts",
+    "publish:linux-browser-libs": "bun scripts/linux-browser-libs.ts publish",
     "pack:smoke": "bun scripts/pack-smoke.ts"
   },
   "dependencies": {

package/src/android-theme.ts

@@ -165,3 +165,17 @@ export function resolveThemeAttribute(
   // unset: the reader's own default applies, as PhoneWindow's getBoolean/getColor do
   return undefined
 }
+
+// a framework color resource as context.getColor reads it, following
+// references to other framework colors
+export function frameworkColor(name: string, sources: ThemeSources): number {
+  let value = sources.android.colors[name]
+  while (value !== undefined && !value.startsWith('#')) {
+    const ref = /^@(?:android:)?color\/(.+)$/.exec(value)
+    if (!ref?.[1])
+      throw new Error(`@android:color/${name} has the unsupported value ${value}`)
+    value = sources.android.colors[ref[1]]
+  }
+  if (value === undefined) throw new Error(`@android:color/${name} is not defined`)
+  return color(value)
+}

package/src/backend-origin.ts

@@ -46,6 +46,31 @@ export function buildBrowserAssetProxyUrl(targetUrl: string): string {
   return `${proxyPath}?url=${encodeURIComponent(targetUrl)}`
 }
 
+export function resolveBrowserAssetProxyUrl(
+  targetUrl: string,
+  currentOrigin: string,
+): string {
+  const proxyUrl = isBrowserAssetProxyUrl(targetUrl)
+    ? targetUrl
+    : buildBrowserAssetProxyUrl(targetUrl)
+  // loopback assets belong to the local bridge; external bytes to the backend.
+  if (proxyUrl.startsWith('/__bundle-proxy?')) return proxyUrl
+  return new URL(proxyUrl, resolveContrastBackendOrigin(currentOrigin)).toString()
+}
+
+export function isBrowserAssetProxyUrl(value: string): boolean {
+  try {
+    const url = new URL(value, DEFAULT_CONTRAST_BACKEND_ORIGIN)
+    return (
+      isContrastBackendOrigin(url.origin) &&
+      url.pathname === '/__fetch-proxy' &&
+      url.searchParams.has('url')
+    )
+  } catch {
+    return false
+  }
+}
+
 export function isContrastBackendHost(hostname: string): boolean {
   const normalized = normalizeHostname(hostname)
   return (