diff --git a/build.gradle.kts b/build.gradle.kts
index 136075093..aa928b9f1 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -73,7 +73,7 @@ subprojects {
       if (file("src/${dokkaSourceSet.name}").exists()) {
 
         val readmeFile = file("$projectDir/README.md")
-        // If the module has a README, add it to the the module's index
+        // If the module has a README, add it to the module's index
         if (readmeFile.exists()) {
           includes.from(readmeFile)
         }
diff --git a/samples/containers/common/src/main/java/com/squareup/sample/container/panel/PanelOverlay.kt b/samples/containers/common/src/main/java/com/squareup/sample/container/panel/PanelOverlay.kt
index b9368f559..f4de422e8 100644
--- a/samples/containers/common/src/main/java/com/squareup/sample/container/panel/PanelOverlay.kt
+++ b/samples/containers/common/src/main/java/com/squareup/sample/container/panel/PanelOverlay.kt
@@ -6,6 +6,9 @@ import com.squareup.workflow1.ui.container.ModalOverlay
 import com.squareup.workflow1.ui.container.ScreenOverlay
 
 @OptIn(WorkflowUiExperimentalApi::class)
-class PanelOverlay<T : Screen>(
-  override val content: T
-) : ScreenOverlay<T>, ModalOverlay
+class PanelOverlay<C : Screen>(
+  override val content: C
+) : ScreenOverlay<C>, ModalOverlay {
+  override fun <D : Screen> map(transform: (C) -> D): PanelOverlay<D> =
+    PanelOverlay(transform(content))
+}
diff --git a/samples/nested-overlays/build.gradle.kts b/samples/nested-overlays/build.gradle.kts
new file mode 100644
index 000000000..7d31f7a46
--- /dev/null
+++ b/samples/nested-overlays/build.gradle.kts
@@ -0,0 +1,25 @@
+plugins {
+  id("com.android.application")
+  `kotlin-android`
+  `android-sample-app`
+  `android-ui-tests`
+}
+
+android {
+  defaultConfig {
+    applicationId = "com.squareup.sample.nestedoverlays"
+  }
+  namespace = "com.squareup.sample.nestedoverlays"
+}
+
+dependencies {
+  debugImplementation(libs.squareup.leakcanary.android)
+
+  implementation(libs.androidx.activity.ktx)
+  implementation(libs.androidx.lifecycle.viewmodel.ktx)
+  implementation(libs.androidx.lifecycle.viewmodel.savedstate)
+  implementation(libs.androidx.viewbinding)
+
+  implementation(project(":workflow-ui:core-android"))
+  implementation(project(":workflow-ui:core-common"))
+}
diff --git a/samples/nested-overlays/lint-baseline.xml b/samples/nested-overlays/lint-baseline.xml
new file mode 100644
index 000000000..4aec7fcd5
--- /dev/null
+++ b/samples/nested-overlays/lint-baseline.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<issues format="6" by="lint 7.4.1" type="baseline" client="gradle" dependencies="false" name="AGP (7.4.1)" variant="fatal" version="7.4.1">
+
+</issues>
diff --git a/samples/nested-overlays/src/androidTest/java/com/squareup/sample/nestedoverlays/NestedOverlaysAppTest.kt b/samples/nested-overlays/src/androidTest/java/com/squareup/sample/nestedoverlays/NestedOverlaysAppTest.kt
new file mode 100644
index 000000000..c616d62a1
--- /dev/null
+++ b/samples/nested-overlays/src/androidTest/java/com/squareup/sample/nestedoverlays/NestedOverlaysAppTest.kt
@@ -0,0 +1,99 @@
+package com.squareup.sample.nestedoverlays
+
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.ViewInteraction
+import androidx.test.espresso.action.ViewActions.click
+import androidx.test.espresso.assertion.ViewAssertions.doesNotExist
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.withParent
+import androidx.test.espresso.matcher.ViewMatchers.withParentIndex
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import androidx.test.ext.junit.rules.ActivityScenarioRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.squareup.workflow1.ui.internal.test.IdlingDispatcherRule
+import leakcanary.DetectLeaksAfterTestSuccess
+import org.hamcrest.core.AllOf.allOf
+import org.hamcrest.core.IsNot.not
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.RuleChain
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class NestedOverlaysAppTest {
+
+  private val scenarioRule = ActivityScenarioRule(NestedOverlaysActivity::class.java)
+
+  @get:Rule val rules: RuleChain = RuleChain.outerRule(DetectLeaksAfterTestSuccess())
+    .around(scenarioRule)
+    .around(IdlingDispatcherRule)
+
+  @Test fun basics() {
+    onTopCoverBody().assertDisplayed()
+    onTopCoverEverything().assertDisplayed()
+    onBottomCoverBody().assertDisplayed()
+    onBottomCoverEverything().assertDisplayed()
+
+    onTopCoverBody().perform(click())
+    onView(withText("Close")).perform(click())
+    onTopCoverEverything().perform(click())
+    onView(withText("Close")).perform(click())
+
+    onView(withText("Hide Top Bar")).perform(click())
+    onTopCoverBody().assertNotDisplayed()
+    onTopCoverEverything().assertNotDisplayed()
+    onBottomCoverBody().assertDisplayed()
+    onBottomCoverEverything().assertDisplayed()
+
+    onView(withText("Hide Bottom Bar")).perform(click())
+    onTopCoverBody().assertNotDisplayed()
+    onTopCoverEverything().assertNotDisplayed()
+    onBottomCoverBody().assertNotDisplayed()
+    onBottomCoverEverything().assertNotDisplayed()
+  }
+
+  // https://github.com/square/workflow-kotlin/issues/966
+  @Test fun canInsertDialog() {
+    onTopCoverEverything().perform(click())
+    onView(withText("Hide Top Bar")).check(doesNotExist())
+    onView(withText("Cover Body")).perform(click())
+
+    // This line fails due to https://github.com/square/workflow-kotlin/issues/966
+    // onView(withText("Hide Top Bar")).check(doesNotExist())
+
+    // Should continue to close the top sheet and assert that the inner sheet is visible.
+  }
+
+  // So far can't express this in Espresso. Considering move to Maestro
+  // @Test fun canClickPastInnerWindow() {
+  //   onView(allOf(withText("Cover Everything"), withParent(withParentIndex(0))))
+  //     .perform(click())
+  //
+  //   scenario.onActivity { activity ->
+  //     onView(allOf(withText("Cover Everything"), withParent(withParentIndex(0))))
+  //       .inRoot(withDecorView(not(`is`(activity.window.decorView))))
+  //       .perform(click())
+  //   }
+  // }
+
+  private fun ViewInteraction.assertNotDisplayed() {
+    check(matches(not(isDisplayed())))
+  }
+
+  private fun ViewInteraction.assertDisplayed() {
+    check(matches(isDisplayed()))
+  }
+
+  private fun onBottomCoverEverything() =
+    onView(allOf(withText("Cover Everything"), withParent(withParentIndex(2))))
+
+  private fun onBottomCoverBody() =
+    onView(allOf(withText("Cover Body"), withParent(withParentIndex(2))))
+
+  private fun onTopCoverBody() =
+    onView(allOf(withText("Cover Body"), withParent(withParentIndex(0))))
+
+  private fun onTopCoverEverything() =
+    onView(allOf(withText("Cover Everything"), withParent(withParentIndex(0))))
+}
diff --git a/samples/nested-overlays/src/main/AndroidManifest.xml b/samples/nested-overlays/src/main/AndroidManifest.xml
new file mode 100644
index 000000000..594e1fde1
--- /dev/null
+++ b/samples/nested-overlays/src/main/AndroidManifest.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+  <application
+      android:allowBackup="false"
+      android:label="@string/app_name"
+      android:theme="@style/AppTheme"
+      tools:ignore="GoogleAppIndexingWarning,MissingApplicationIcon"
+      >
+
+    <activity android:name="com.squareup.sample.nestedoverlays.NestedOverlaysActivity"
+        android:exported="true">
+
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+
+    </activity>
+
+  </application>
+</manifest>
diff --git a/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/ButtonBar.kt b/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/ButtonBar.kt
new file mode 100644
index 000000000..37f9f7726
--- /dev/null
+++ b/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/ButtonBar.kt
@@ -0,0 +1,53 @@
+package com.squareup.sample.nestedoverlays
+
+import android.graphics.drawable.ColorDrawable
+import android.view.Gravity
+import android.widget.LinearLayout
+import androidx.annotation.ColorRes
+import androidx.annotation.StringRes
+import androidx.core.view.get
+import com.squareup.workflow1.ui.AndroidScreen
+import com.squareup.workflow1.ui.ScreenViewFactory
+import com.squareup.workflow1.ui.ScreenViewHolder
+import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
+import android.widget.Button as ButtonView
+
+data class Button(
+  @StringRes val name: Int,
+  val onClick: () -> Unit
+)
+
+@OptIn(WorkflowUiExperimentalApi::class)
+class ButtonBar(
+  vararg buttons: Button?,
+  @ColorRes val color: Int = -1,
+) : AndroidScreen<ButtonBar> {
+  private val buttons: List<Button> = buttons.filterNotNull().toList()
+
+  override val viewFactory =
+    ScreenViewFactory.fromCode<ButtonBar> { _, initialEnvironment, context, _ ->
+      LinearLayout(context).let { view ->
+        @Suppress("DEPRECATION")
+        if (color > -1) view.background = ColorDrawable(view.resources.getColor(color))
+
+        view.gravity = Gravity.CENTER
+
+        ScreenViewHolder(initialEnvironment, view) { bar, _ ->
+          val existing = view.childCount
+
+          bar.buttons.forEachIndexed { index, button ->
+            val buttonView = if (index < existing) {
+              view[index] as ButtonView
+            } else {
+              ButtonView(context).also { view.addView(it) }
+            }
+            with(buttonView) {
+              text = view.resources.getText(button.name)
+              setOnClickListener { button.onClick() }
+            }
+          }
+          for (i in bar.buttons.size until view.childCount) view.removeViewAt(i)
+        }
+      }
+    }
+}
diff --git a/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/NestedOverlaysActivity.kt b/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/NestedOverlaysActivity.kt
new file mode 100644
index 000000000..97bcefada
--- /dev/null
+++ b/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/NestedOverlaysActivity.kt
@@ -0,0 +1,44 @@
+@file:OptIn(WorkflowExperimentalRuntime::class)
+
+package com.squareup.sample.nestedoverlays
+
+import android.os.Bundle
+import androidx.activity.viewModels
+import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.squareup.workflow1.WorkflowExperimentalRuntime
+import com.squareup.workflow1.config.AndroidRuntimeConfigTools
+import com.squareup.workflow1.ui.Screen
+import com.squareup.workflow1.ui.WorkflowLayout
+import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
+import com.squareup.workflow1.ui.renderWorkflowIn
+import kotlinx.coroutines.flow.StateFlow
+
+@OptIn(WorkflowUiExperimentalApi::class)
+class NestedOverlaysActivity : AppCompatActivity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    // This ViewModel will survive configuration changes. It's instantiated
+    // by the first call to viewModels(), and that original instance is returned by
+    // succeeding calls.
+    val model: NestedOverlaysViewModel by viewModels()
+    setContentView(
+      WorkflowLayout(this).apply { take(lifecycle, model.renderings) }
+    )
+  }
+}
+
+class NestedOverlaysViewModel(savedState: SavedStateHandle) : ViewModel() {
+  @OptIn(WorkflowUiExperimentalApi::class)
+  val renderings: StateFlow<Screen> by lazy {
+    renderWorkflowIn(
+      workflow = NestedOverlaysWorkflow,
+      scope = viewModelScope,
+      savedStateHandle = savedState,
+      runtimeConfig = AndroidRuntimeConfigTools.getAppWorkflowRuntimeConfig()
+    )
+  }
+}
diff --git a/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/NestedOverlaysWorkflow.kt b/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/NestedOverlaysWorkflow.kt
new file mode 100644
index 000000000..837faea90
--- /dev/null
+++ b/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/NestedOverlaysWorkflow.kt
@@ -0,0 +1,113 @@
+@file:OptIn(WorkflowUiExperimentalApi::class)
+
+package com.squareup.sample.nestedoverlays
+
+import com.squareup.sample.nestedoverlays.NestedOverlaysWorkflow.State
+import com.squareup.workflow1.Snapshot
+import com.squareup.workflow1.StatefulWorkflow
+import com.squareup.workflow1.ui.Screen
+import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
+import com.squareup.workflow1.ui.container.BodyAndOverlaysScreen
+import com.squareup.workflow1.ui.container.FullScreenOverlay
+import com.squareup.workflow1.ui.container.Overlay
+
+typealias NestedOverlaysRendering = BodyAndOverlaysScreen<
+  TopAndBottomBarsScreen<BodyAndOverlaysScreen<Screen, Overlay>>,
+  Overlay
+  >
+
+object NestedOverlaysWorkflow : StatefulWorkflow<Unit, State, Nothing, NestedOverlaysRendering>() {
+  data class State(
+    val showTopBar: Boolean = true,
+    val showBottomBar: Boolean = true,
+    val showInnerSheet: Boolean = false,
+    val showOuterSheet: Boolean = false
+  )
+
+  override fun initialState(
+    props: Unit,
+    snapshot: Snapshot?
+  ) = State()
+
+  override fun render(
+    renderProps: Unit,
+    renderState: State,
+    context: RenderContext
+  ): NestedOverlaysRendering {
+    val toggleTopBarButton = Button(
+      name = if (renderState.showTopBar) R.string.HIDE_TOP else R.string.SHOW_TOP,
+      onClick = context.eventHandler { state = state.copy(showTopBar = !state.showTopBar) }
+    )
+
+    val toggleBottomBarButton = Button(
+      name = if (renderState.showBottomBar) R.string.HIDE_BOTTOM else R.string.SHOW_BOTTOM,
+      onClick = context.eventHandler { state = state.copy(showBottomBar = !state.showBottomBar) }
+    )
+
+    val outerSheet = if (!renderState.showOuterSheet) {
+      null
+    } else {
+      FullScreenOverlay(
+        ButtonBar(
+          Button(
+            name = R.string.CLOSE,
+            onClick = context.eventHandler { state = state.copy(showOuterSheet = false) }
+          ),
+          context.toggleInnerSheetButton(renderState),
+          color = android.R.color.holo_green_light
+        )
+      )
+    }
+
+    val innerSheet = if (!renderState.showInnerSheet) {
+      null
+    } else {
+      FullScreenOverlay(
+        ButtonBar(
+          Button(
+            name = R.string.CLOSE,
+            onClick = context.eventHandler { state = state.copy(showInnerSheet = false) }
+          ),
+          toggleTopBarButton,
+          toggleBottomBarButton,
+          color = android.R.color.holo_red_light
+        )
+      )
+    }
+    val bodyBarButtons = ButtonBar(toggleTopBarButton, toggleBottomBarButton)
+
+    return BodyAndOverlaysScreen(
+      name = "outer",
+      overlays = listOfNotNull(outerSheet),
+      body = TopAndBottomBarsScreen(
+        topBar = if (!renderState.showTopBar) null else context.topBottomBar(renderState),
+        content = BodyAndOverlaysScreen(
+          name = "inner",
+          body = bodyBarButtons,
+          overlays = listOfNotNull(innerSheet)
+        ),
+        bottomBar = if (!renderState.showBottomBar) null else context.topBottomBar(renderState)
+      )
+    )
+  }
+
+  override fun snapshotState(state: State) = null
+
+  private fun RenderContext.topBottomBar(
+    renderState: State
+  ) = ButtonBar(
+    toggleInnerSheetButton(renderState),
+    Button(
+      name = R.string.COVER_ALL,
+      onClick = eventHandler { state = state.copy(showOuterSheet = true) }
+    )
+  )
+
+  private fun RenderContext.toggleInnerSheetButton(renderState: State) =
+    Button(
+      name = if (renderState.showInnerSheet) R.string.REVEAL_BODY else R.string.COVER_BODY,
+      onClick = eventHandler {
+        state = state.copy(showInnerSheet = !state.showInnerSheet)
+      }
+    )
+}
diff --git a/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/TopAndBottomBarsScreen.kt b/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/TopAndBottomBarsScreen.kt
new file mode 100644
index 000000000..9314cd33b
--- /dev/null
+++ b/samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/TopAndBottomBarsScreen.kt
@@ -0,0 +1,31 @@
+package com.squareup.sample.nestedoverlays
+
+import android.view.View.GONE
+import android.view.View.VISIBLE
+import com.squareup.sample.nestedoverlays.databinding.TopAndBottomBarsBinding
+import com.squareup.workflow1.ui.AndroidScreen
+import com.squareup.workflow1.ui.Screen
+import com.squareup.workflow1.ui.ScreenViewFactory
+import com.squareup.workflow1.ui.ScreenViewFactory.Companion.fromViewBinding
+import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
+import com.squareup.workflow1.ui.Wrapper
+
+@OptIn(WorkflowUiExperimentalApi::class)
+data class TopAndBottomBarsScreen<T : Screen>(
+  override val content: T,
+  val topBar: ButtonBar? = null,
+  val bottomBar: ButtonBar? = null
+) : AndroidScreen<TopAndBottomBarsScreen<T>>, Wrapper<Screen, T> {
+  override fun <ContentU : Screen> map(transform: (T) -> ContentU) =
+    TopAndBottomBarsScreen(transform(content), topBar, bottomBar)
+
+  override val viewFactory: ScreenViewFactory<TopAndBottomBarsScreen<T>> =
+    fromViewBinding(TopAndBottomBarsBinding::inflate) { screen, environment ->
+      bodyStub.show(screen.content, environment)
+
+      screen.topBar?.let { topBarStub.show(it, environment) }
+      screen.bottomBar?.let { bottomBarStub.show(it, environment) }
+      topBarStub.actual.visibility = if (screen.topBar != null) VISIBLE else GONE
+      bottomBarStub.actual.visibility = if (screen.bottomBar != null) VISIBLE else GONE
+    }
+}
diff --git a/samples/nested-overlays/src/main/res/layout/top_and_bottom_bars.xml b/samples/nested-overlays/src/main/res/layout/top_and_bottom_bars.xml
new file mode 100644
index 000000000..91fe7a7da
--- /dev/null
+++ b/samples/nested-overlays/src/main/res/layout/top_and_bottom_bars.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:background="@android:color/holo_orange_light"
+    >
+
+  <com.squareup.workflow1.ui.WorkflowViewStub
+      android:id="@+id/top_bar_stub"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      />
+
+  <com.squareup.workflow1.ui.WorkflowViewStub
+      android:id="@+id/body_stub"
+      android:layout_width="match_parent"
+      android:layout_height="0dp"
+      android:layout_weight="1"
+      />
+
+  <com.squareup.workflow1.ui.WorkflowViewStub
+      android:id="@+id/bottom_bar_stub"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      />
+
+</LinearLayout>
diff --git a/samples/nested-overlays/src/main/res/values/strings.xml b/samples/nested-overlays/src/main/res/values/strings.xml
new file mode 100644
index 000000000..5323fbc97
--- /dev/null
+++ b/samples/nested-overlays/src/main/res/values/strings.xml
@@ -0,0 +1,13 @@
+<resources>
+  <string name="app_name">Nested Overlays</string>
+  <string name="BODY">body</string>
+  <string name="COVER_BODY">Cover Body</string>
+  <string name="BOTTOM">bottom</string>
+  <string name="HIDE_BOTTOM">Hide Bottom Bar</string>
+  <string name="SHOW_BOTTOM">Show Bottom Bar</string>
+  <string name="HIDE_TOP">Hide Top Bar</string>
+  <string name="SHOW_TOP">Show Top Bar</string>
+  <string name="REVEAL_BODY">Reveal Body</string>
+  <string name="COVER_ALL">Cover Everything</string>
+  <string name="CLOSE">Close</string>
+</resources>
diff --git a/samples/nested-overlays/src/main/res/values/styles.xml b/samples/nested-overlays/src/main/res/values/styles.xml
new file mode 100644
index 000000000..e2331afcc
--- /dev/null
+++ b/samples/nested-overlays/src/main/res/values/styles.xml
@@ -0,0 +1,8 @@
+<resources>
+
+  <!-- Base application theme. -->
+  <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar">
+    <!-- Customize your theme here. -->
+  </style>
+
+</resources>
diff --git a/samples/tictactoe/common/src/main/java/com/squareup/sample/gameworkflow/RunGameWorkflow.kt b/samples/tictactoe/common/src/main/java/com/squareup/sample/gameworkflow/RunGameWorkflow.kt
index 845c2a970..5d65ef66e 100644
--- a/samples/tictactoe/common/src/main/java/com/squareup/sample/gameworkflow/RunGameWorkflow.kt
+++ b/samples/tictactoe/common/src/main/java/com/squareup/sample/gameworkflow/RunGameWorkflow.kt
@@ -29,7 +29,6 @@ import com.squareup.workflow1.ui.container.AlertOverlay.Button.NEUTRAL
 import com.squareup.workflow1.ui.container.AlertOverlay.Button.POSITIVE
 import com.squareup.workflow1.ui.container.AlertOverlay.Event.ButtonClicked
 import com.squareup.workflow1.ui.container.AlertOverlay.Event.Canceled
-import com.squareup.workflow1.ui.container.ScreenOverlay
 
 enum class RunGameResult {
   CanceledStart,
@@ -37,14 +36,15 @@ enum class RunGameResult {
 }
 
 /**
- * This workflow renders up to three layers. There is always a [gameScreen], which
- * may be covered by a [namePrompt] and [alerts]. By declaring our rendering shape
- * this explicitly, we give parent workflows just enough information to recompose,
- * without leaking details about every single type of screen we render.
+ * This workflow renders in up to three parts, whose display a parent is responsible for
+ * managing. There is always a [gameScreen], which may be augmented by a [namePrompt]
+ * and [alerts]. By declaring our rendering shape this explicitly, we give parent workflows
+ * just enough information to recompose, without leaking details about every single type
+ * of screen we render.
  */
 data class RunGameRendering(
   val gameScreen: Screen,
-  val namePrompt: ScreenOverlay<*>? = null,
+  val namePrompt: Screen? = null,
   val alerts: List<AlertOverlay> = emptyList()
 )
 
@@ -52,7 +52,6 @@ data class RunGameRendering(
  * We define this otherwise redundant typealias to keep composite workflows
  * that build on [RunGameWorkflow] decoupled from it, for ease of testing.
  */
-@OptIn(WorkflowUiExperimentalApi::class)
 typealias RunGameWorkflow =
   Workflow<Unit, RunGameResult, RunGameRendering>
 
@@ -86,14 +85,12 @@ class RealRunGameWorkflow(
 
         RunGameRendering(
           gameScreen = emptyGameScreen,
-          namePrompt = object : ScreenOverlay<Screen> {
-            override val content = NewGameScreen(
-              renderState.defaultXName,
-              renderState.defaultOName,
-              onCancel = context.eventHandler { setOutput(CanceledStart) },
-              onStartGame = context.eventHandler { x, o -> state = Playing(PlayerInfo(x, o)) }
-            )
-          }
+          namePrompt = NewGameScreen(
+            renderState.defaultXName,
+            renderState.defaultOName,
+            onCancel = context.eventHandler { setOutput(CanceledStart) },
+            onStartGame = context.eventHandler { x, o -> state = Playing(PlayerInfo(x, o)) }
+          )
         )
       }
 
@@ -233,6 +230,7 @@ class RealRunGameWorkflow(
             NEGATIVE -> continuePlaying()
             NEUTRAL -> throw IllegalArgumentException()
           }
+
           Canceled -> continuePlaying()
         }
       }
diff --git a/samples/tictactoe/common/src/main/java/com/squareup/sample/mainworkflow/TicTacToeWorkflow.kt b/samples/tictactoe/common/src/main/java/com/squareup/sample/mainworkflow/TicTacToeWorkflow.kt
index 4db026a4c..265c3843b 100644
--- a/samples/tictactoe/common/src/main/java/com/squareup/sample/mainworkflow/TicTacToeWorkflow.kt
+++ b/samples/tictactoe/common/src/main/java/com/squareup/sample/mainworkflow/TicTacToeWorkflow.kt
@@ -91,8 +91,7 @@ class TicTacToeWorkflow(
           // Authenticating state was allowed to die, so that this one will start fresh
           // in its logged out state.
           val stubAuthBackStack = context.renderChild(authWorkflow, "fake") { noAction() }
-          val fullBackStack = stubAuthBackStack +
-            BackStackScreen(gameRendering.namePrompt.content)
+          val fullBackStack = stubAuthBackStack + BackStackScreen(gameRendering.namePrompt)
           val allModals = listOf(PanelOverlay(fullBackStack)) + gameRendering.alerts
 
           BodyAndOverlaysScreen(gameRendering.gameScreen, allModals)
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 662672fed..c2a8ddcac 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -55,6 +55,7 @@ include(
   ":samples:hello-terminal:todo-terminal-app",
   ":samples:hello-workflow",
   ":samples:hello-workflow-fragment",
+  ":samples:nested-overlays",
   ":samples:stub-visibility",
   ":samples:tictactoe:app",
   ":samples:tictactoe:common",
diff --git a/workflow-testing/src/main/java/com/squareup/workflow1/testing/WorkerTester.kt b/workflow-testing/src/main/java/com/squareup/workflow1/testing/WorkerTester.kt
index 9a85510a4..3ba94da61 100644
--- a/workflow-testing/src/main/java/com/squareup/workflow1/testing/WorkerTester.kt
+++ b/workflow-testing/src/main/java/com/squareup/workflow1/testing/WorkerTester.kt
@@ -19,8 +19,9 @@ public interface WorkerTester<T> {
    * Access the [TestCoroutineScheduler] of the [kotlinx.coroutines.test.TestScope] running
    * the [Worker]'s [test].
    *
-   * This can be used to advance virtual time for the [CoroutineDispatcher] that the the Worker's
-   * flow is flowing on.
+   * This can be used to advance virtual time for the
+   * [CoroutineDispatcher][kotlinx.coroutines.CoroutineDispatcher]
+   * that the Worker's flow is flowing on.
    */
   public val testCoroutineScheduler: TestCoroutineScheduler
 
diff --git a/workflow-ui/compose/src/androidTest/java/com/squareup/workflow1/ui/compose/ComposeViewTreeIntegrationTest.kt b/workflow-ui/compose/src/androidTest/java/com/squareup/workflow1/ui/compose/ComposeViewTreeIntegrationTest.kt
index 5f7711963..2898e8ea3 100644
--- a/workflow-ui/compose/src/androidTest/java/com/squareup/workflow1/ui/compose/ComposeViewTreeIntegrationTest.kt
+++ b/workflow-ui/compose/src/androidTest/java/com/squareup/workflow1/ui/compose/ComposeViewTreeIntegrationTest.kt
@@ -570,6 +570,8 @@ internal class ComposeViewTreeIntegrationTest {
   data class TestModal(
     override val content: Screen
   ) : ScreenOverlay<Screen>, AndroidOverlay<TestModal> {
+    override fun <ContentU : Screen> map(transform: (Screen) -> ContentU) = error("Not implemented")
+
     override val dialogFactory = object : ScreenOverlayDialogFactory<Screen, TestModal>(
       TestModal::class
     ) {
diff --git a/workflow-ui/container-android/src/main/java/com/squareup/workflow1/ui/modal/ModalContainer.kt b/workflow-ui/container-android/src/main/java/com/squareup/workflow1/ui/modal/ModalContainer.kt
index a28b2c572..edb8b086d 100644
--- a/workflow-ui/container-android/src/main/java/com/squareup/workflow1/ui/modal/ModalContainer.kt
+++ b/workflow-ui/container-android/src/main/java/com/squareup/workflow1/ui/modal/ModalContainer.kt
@@ -47,7 +47,7 @@ public abstract class ModalContainer<ModalRenderingT : Any> @JvmOverloads constr
 
   /**
    * Stores the result of looking for the nearest [LifecycleOwner] that should be the parent of all
-   * this container's modals. Only valid after the the view has been attached.
+   * this container's modals. Only valid after the view has been attached.
    */
   private val parentLifecycleOwner by lazy(mode = LazyThreadSafetyMode.NONE) {
     WorkflowLifecycleOwner.get(this) ?: error(
diff --git a/workflow-ui/core-android/api/core-android.api b/workflow-ui/core-android/api/core-android.api
index fe892fc3a..508fe71a2 100644
--- a/workflow-ui/core-android/api/core-android.api
+++ b/workflow-ui/core-android/api/core-android.api
@@ -306,6 +306,7 @@ public final class com/squareup/workflow1/ui/container/AlertOverlayDialogFactory
 }
 
 public final class com/squareup/workflow1/ui/container/AndroidDialogBoundsKt {
+	public static final fun getScreenRect (Landroid/view/View;Landroid/graphics/Rect;)V
 	public static final fun setBounds (Landroid/app/Dialog;Landroid/graphics/Rect;)V
 }
 
@@ -313,13 +314,20 @@ public abstract interface class com/squareup/workflow1/ui/container/AndroidOverl
 	public abstract fun getDialogFactory ()Lcom/squareup/workflow1/ui/container/OverlayDialogFactory;
 }
 
-public final class com/squareup/workflow1/ui/container/BackButtonScreen : com/squareup/workflow1/ui/AndroidScreen {
+public final class com/squareup/workflow1/ui/container/BackButtonScreen : com/squareup/workflow1/ui/AndroidScreen, com/squareup/workflow1/ui/Wrapper {
 	public fun <init> (Lcom/squareup/workflow1/ui/Screen;ZLkotlin/jvm/functions/Function0;)V
 	public synthetic fun <init> (Lcom/squareup/workflow1/ui/Screen;ZLkotlin/jvm/functions/Function0;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun asSequence ()Lkotlin/sequences/Sequence;
+	public fun getCompatibilityKey ()Ljava/lang/String;
+	public fun getContent ()Lcom/squareup/workflow1/ui/Screen;
+	public synthetic fun getContent ()Ljava/lang/Object;
 	public final fun getOnBackPressed ()Lkotlin/jvm/functions/Function0;
 	public final fun getShadow ()Z
 	public fun getViewFactory ()Lcom/squareup/workflow1/ui/ScreenViewFactory;
 	public final fun getWrapped ()Lcom/squareup/workflow1/ui/Screen;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Container;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Wrapper;
+	public fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/BackButtonScreen;
 }
 
 public final class com/squareup/workflow1/ui/container/BackStackConfig : java/lang/Enum {
diff --git a/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/BackStackContainerTest.kt b/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/BackStackContainerTest.kt
index ee0192873..56633e306 100644
--- a/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/BackStackContainerTest.kt
+++ b/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/BackStackContainerTest.kt
@@ -167,7 +167,7 @@ internal class BackStackContainerTest {
     var transitionCount = 0
 
     val visibleRendering: Screen
-      get() = (getChildAt(0)?.tag as NamedScreen<*>).wrapped
+      get() = (getChildAt(0)?.tag as NamedScreen<*>).content
 
     override fun performTransition(
       oldHolderMaybe: ScreenViewHolder<NamedScreen<*>>?,
diff --git a/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/DialogIntegrationTest.kt b/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/DialogIntegrationTest.kt
index d23a304b4..fcc20fe9a 100644
--- a/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/DialogIntegrationTest.kt
+++ b/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/DialogIntegrationTest.kt
@@ -10,6 +10,7 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.google.common.truth.Truth.assertThat
 import com.squareup.workflow1.ui.AndroidScreen
 import com.squareup.workflow1.ui.Compatible
+import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.ScreenViewFactory
 import com.squareup.workflow1.ui.ScreenViewHolder
 import com.squareup.workflow1.ui.ViewEnvironment
@@ -47,7 +48,10 @@ internal class DialogIntegrationTest {
     name: String,
     override val content: ContentRendering
   ) :
-    Compatible, AndroidOverlay<DialogRendering>, ScreenOverlay<ContentRendering> {
+    AndroidOverlay<DialogRendering>, ScreenOverlay<ContentRendering> {
+    override fun <ContentU : Screen> map(transform: (ContentRendering) -> ContentU) =
+      error("Not implemented")
+
     override val compatibilityKey = name
     override val dialogFactory =
       object : ScreenOverlayDialogFactory<ContentRendering, DialogRendering>(
diff --git a/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/ViewStateCacheTest.kt b/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/ViewStateCacheTest.kt
index f224b35f4..d1c041d5b 100644
--- a/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/ViewStateCacheTest.kt
+++ b/workflow-ui/core-android/src/androidTest/java/com/squareup/workflow1/ui/container/ViewStateCacheTest.kt
@@ -35,7 +35,7 @@ internal class ViewStateCacheTest {
   private object AScreen : Screen
 
   @Test fun saves_and_restores_self() {
-    val rendering = NamedScreen(wrapped = AScreen, name = "rendering")
+    val rendering = NamedScreen(content = AScreen, name = "rendering")
     val childState = SparseArray<Parcelable>().apply {
       put(0, TestChildState("hello world"))
     }
@@ -68,8 +68,8 @@ internal class ViewStateCacheTest {
 
   @Test fun saves_and_restores_child_states_on_navigation() {
     val cache = ViewStateCache()
-    val firstRendering = NamedScreen(wrapped = AScreen, name = "first")
-    val secondRendering = NamedScreen(wrapped = AScreen, name = "second")
+    val firstRendering = NamedScreen(content = AScreen, name = "first")
+    val secondRendering = NamedScreen(content = AScreen, name = "second")
     // Android requires ID to be set for view hierarchy to be saved or restored.
     val firstView = createTestView(firstRendering, id = 1)
     val secondView = createTestView(secondRendering)
@@ -100,8 +100,8 @@ internal class ViewStateCacheTest {
 
   @Test fun doesnt_restore_state_when_restored_view_id_is_different() {
     val cache = ViewStateCache()
-    val firstRendering = NamedScreen(wrapped = AScreen, name = "first")
-    val secondRendering = NamedScreen(wrapped = AScreen, name = "second")
+    val firstRendering = NamedScreen(content = AScreen, name = "first")
+    val secondRendering = NamedScreen(content = AScreen, name = "second")
     // Android requires ID to be set for view hierarchy to be saved or restored.
     val firstView = createTestView(firstRendering, id = 1)
     val secondView = createTestView(secondRendering)
@@ -143,8 +143,8 @@ internal class ViewStateCacheTest {
 
   @Test fun doesnt_restore_state_when_view_id_not_set() {
     val cache = ViewStateCache()
-    val firstRendering = NamedScreen(wrapped = AScreen, name = "first")
-    val secondRendering = NamedScreen(wrapped = AScreen, name = "second")
+    val firstRendering = NamedScreen(content = AScreen, name = "first")
+    val secondRendering = NamedScreen(content = AScreen, name = "second")
     val firstView = createTestView(firstRendering)
     val secondView = createTestView(secondRendering)
 
@@ -170,7 +170,7 @@ internal class ViewStateCacheTest {
 
   @Test fun throws_on_duplicate_renderings() {
     val cache = ViewStateCache()
-    val rendering = NamedScreen(wrapped = AScreen, name = "duplicate")
+    val rendering = NamedScreen(content = AScreen, name = "duplicate")
     val view = createTestView(rendering)
 
     try {
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/ScreenViewFactory.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/ScreenViewFactory.kt
index 06f4a7a98..9fa05f2e6 100644
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/ScreenViewFactory.kt
+++ b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/ScreenViewFactory.kt
@@ -139,107 +139,83 @@ public interface ScreenViewFactory<in ScreenT : Screen> : ViewRegistry.Entry<Scr
     }
 
     /**
-     * Creates a [ScreenViewFactory] for [WrapperT] that finds and delegates to the one for
-     * [WrappedT]. Allows [WrapperT] to wrap instances of [WrappedT] to add information or behavior,
-     * without requiring wasteful wrapping in the view system.
-     *
-     * One general note: when creating a wrapper rendering, you're very likely to want it to
-     * implement [Compatible], to ensure that checks made to update or replace a view are based on
-     * the wrapped item. Each wrapper example below illustrates this.
-     *
-     * This a simpler variant of the like named function that takes three arguments, for use when
-     * there is no need to manipulate the [ScreenViewHolder].
+     * Creates a [ScreenViewFactory] for type [WrapperT] that finds and delegates to the one for
+     * [WrappedT]. Allows [WrapperT] to add information or behavior, without requiring wasteful
+     * parallel wrapping in the view system.
      *
      * ## Examples
      *
-     * To make one rendering type an "alias" for another -- that is, to use the same
-     * [ScreenViewFactory] to display it:
-     *
-     * class RealScreen(val data: String): AndroidScreen<RealScreen> { override val viewFactory =
-     * fromLayout<RealScreen>(...) }
-     *
-     * class AliasScreen(val similarData: String) : AndroidScreen<AliasScreen> {
-     * override val viewFactory = forWrapper<AliasScreen, RealScreen> { aliasScreen ->
-     * RealScreen(aliasScreen.similarData) } }
-     *
      * To make one [Screen] type a wrapper for others:
      *
-     * class Wrapper<W>(val wrapped: W: Screen) : AndroidScreen<Wrapper<W>>, Compatible {
-     * override val compatibilityKey = Compatible.keyFor(wrapped) override val viewFactory =
-     * ScreenViewFactory.forWrapper<Wrapper<W>, W> { it.wrapped } }
-     *
-     * To make a wrapper that adds information to the [ViewEnvironment]:
+     *    class MyWrapper<W : Screen>(
+     *      override val content: W
+     *    ) : AndroidScreen<Wrapper<W>>, Wrapper<Screen, W> {
+     *      override val viewFactory = forWrapper<MyWrapper<W>, W>()
      *
-     * class ReverseNeutronFlowPolarity : ViewEnvironmentKey<Boolean>(Boolean::class) { override val
-     * default = false }
+     *      override fun <U : Screen> map(transform: (W) -> U) =
+     *        MyWrapper(transform(content))
+     *    }
      *
-     * class ReversePolarityScreen<W : Screen>( val wrapped: W ) :
-     * AndroidScreen<ReversePolarityScreen<W>>, Compatible { override val compatibilityKey: String
-     * = Compatible.keyFor(wrapped) override val viewFactory = forWrapper<OverrideNeutronFlow<W>,
-     * Screen> { it.wrapped.withEnvironment( Environment.EMPTY + (ReverseNeutronFlowPolarity to
-     * true) ) } }
+     * To make a wrapper that customizes [View] initialization:
      *
-     * @param unwrap a function to extract [WrappedT] instances from [WrapperT]s.
-     */
-    @WorkflowUiExperimentalApi
-    public inline fun <
-      reified WrapperT : Screen,
-      WrappedT : Screen
-      > forWrapper(
-      crossinline unwrap: (wrapperScreen: WrapperT) -> WrappedT,
-    ): ScreenViewFactory<WrapperT> = forWrapper(
-      unwrap = unwrap,
-      beforeShowing = {}
-    ) { _, wrapper, e, showWrapper ->
-      showWrapper(unwrap(wrapper), e)
-    }
-
-    /**
-     * Creates a [ScreenViewFactory] for [WrapperT] that finds and delegates to the one for
-     * [WrappedT]. Allows [WrapperT] to wrap instances of [WrappedT] to add information or behavior,
-     * without requiring wasteful wrapping in the view system.
+     *    class WithTutorialTips<W : Screen>(
+     *      override val content: W
+     *    ) : AndroidScreen<WithTutorialTips<W>>, Wrapper<Screen, W> {
+     *      override val viewFactory = forWrapper<WithTutorialTips<W>, W>(
+     *        beforeShowing = { TutorialTipRunner.initialize(it.view) }
+     *      )
      *
-     * This fully featured variant of the function is able to initialize the freshly created
-     * [ScreenViewHolder], and transform the wrapped [ScreenViewHolder.runner].
+     *      override fun <U : Screen> map(transform: (W) -> U) =
+     *        WithTutorialTips(transform(content))
+     *    }
      *
-     * To make a wrapper that customizes [View] initialization:
+     * @param prepEnvironment a function to process the initial [ViewEnvironment]
+     * before the [ScreenViewFactory] is fetched. Note that this function is not
+     * applied on updates. Add a [showWrapperScreen] function if you need that.
      *
-     * class WithTutorialTips<W : Screen>( val wrapped: W ) : AndroidScreen<WithTutorialTips<W>>,
-     * Compatible { override val compatibilityKey = Compatible.keyFor(wrapped) override
-     * val viewFactory = forWrapper<WithTutorialTips<W>, W>( unwrap = { it.wrapped },
-     * beforeShowing = { TutorialTipRunner.initialize(it.view) }, showWrapperScreen = { _,
-     * wrapper, environment, showWrapper -> showWrapper(unwrap(wrapper), environment) } ) }
+     * @param prepContext a function to process the [Context] used to create each [View].
+     * it is passed the product of [prepEnvironment]
      *
      * @param unwrap a function to extract [WrappedT] instances from [WrapperT]s.
+     *
      * @param beforeShowing a function to be invoked immediately after a new [View] is built.
-     * @param showWrapperScreen a function to be invoked when an instance of [WrapperT] needs to be
-     *     shown in a [View] built to display instances of [WrappedT]. Allows pre- and
-     *     post-processing of the [View].
+     *
+     * @param showWrapperScreen a function to be invoked when an instance of [WrapperT] needs
+     * to be shown in a [View] built to display instances of [WrappedT]. Allows pre-
+     * and post-processing of the [View].
      */
     @WorkflowUiExperimentalApi
-    public inline fun <
-      reified WrapperT : Screen,
-      WrappedT : Screen
-      > forWrapper(
-      crossinline unwrap: (wrapperScreen: WrapperT) -> WrappedT,
+    public inline fun <reified WrapperT, WrappedT : Screen> forWrapper(
+      crossinline prepEnvironment: (environment: ViewEnvironment) -> ViewEnvironment = { it },
+      crossinline prepContext: (
+        environment: ViewEnvironment,
+        context: Context
+      ) -> Context = { _, c -> c },
+      crossinline unwrap: (wrapperScreen: WrapperT) -> WrappedT = { it.content },
       crossinline beforeShowing: (viewHolder: ScreenViewHolder<WrapperT>) -> Unit = {},
       crossinline showWrapperScreen: (
         view: View,
         wrapperScreen: WrapperT,
         environment: ViewEnvironment,
         showUnwrappedScreen: (WrappedT, ViewEnvironment) -> Unit
-      ) -> Unit,
-    ): ScreenViewFactory<WrapperT> =
-      fromCode { initialRendering, initialEnvironment, context, container ->
-        val wrappedFactory = unwrap(initialRendering).toViewFactory(initialEnvironment)
-        val wrapperFactory = wrappedFactory.toUnwrappingViewFactory(unwrap, showWrapperScreen)
-        wrapperFactory.buildView(
-          initialRendering,
-          initialEnvironment,
-          context,
-          container
-        ).also { beforeShowing(it) }
+      ) -> Unit = { _, wrapper, e, showWrapper -> showWrapper(wrapper.content, e) },
+    ): ScreenViewFactory<WrapperT> where WrapperT : Screen, WrapperT : Wrapper<Screen, WrappedT> {
+      return fromCode { initialRendering, initialEnvironment, context, container ->
+        val preppedEnvironment = prepEnvironment(initialEnvironment)
+        val wrappedFactory = unwrap(initialRendering).toViewFactory(preppedEnvironment)
+        val wrapperFactory = wrappedFactory.toUnwrappingViewFactory(
+          prepEnvironment,
+          prepContext,
+          unwrap,
+          showWrapperScreen
+        )
+
+        // Note that we give the factory the original initialEnvironment.
+        // It applies prepEnvironment itself.
+        wrapperFactory.buildView(initialRendering, initialEnvironment, context, container)
+          .also { beforeShowing(it) }
       }
+    }
   }
 }
 
@@ -353,43 +329,34 @@ public fun interface ViewStarter {
  * @see [ScreenViewFactory.forWrapper].
  */
 @WorkflowUiExperimentalApi
-public inline fun <
-  reified WrapperT : Screen,
-  WrappedT : Screen
-  > ScreenViewFactory<WrappedT>.toUnwrappingViewFactory(
-  crossinline unwrap: (wrapperScreen: WrapperT) -> WrappedT
-): ScreenViewFactory<WrapperT> {
-  return toUnwrappingViewFactory(unwrap) { _, wrapperScreen, environment, showUnwrappedScreen ->
-    showUnwrappedScreen(unwrap(wrapperScreen), environment)
-  }
-}
-
-/**
- * Transforms a [ScreenViewFactory] of [WrappedT] into one that can handle instances of [WrapperT].
- *
- * @see [ScreenViewFactory.forWrapper].
- */
-@WorkflowUiExperimentalApi
-public inline fun <
-  reified WrapperT : Screen,
-  WrappedT : Screen
-  > ScreenViewFactory<WrappedT>.toUnwrappingViewFactory(
-  crossinline unwrap: (wrapperScreen: WrapperT) -> WrappedT,
+public inline fun <reified WrapperT, WrappedT> ScreenViewFactory<WrappedT>.toUnwrappingViewFactory(
+  crossinline prepEnvironment: (environment: ViewEnvironment) -> ViewEnvironment = { e -> e },
+  crossinline prepContext: (
+    environment: ViewEnvironment,
+    context: Context
+  ) -> Context = { _, c -> c },
+  crossinline unwrap: (wrapperScreen: WrapperT) -> WrappedT = { it.content },
   crossinline showWrapperScreen: (
     view: View,
     wrapperScreen: WrapperT,
     environment: ViewEnvironment,
     showUnwrappedScreen: (WrappedT, ViewEnvironment) -> Unit
-  ) -> Unit
-): ScreenViewFactory<WrapperT> {
+  ) -> Unit = { _, wrapperScreen, environment, showUnwrappedScreen ->
+    showUnwrappedScreen(wrapperScreen.content, environment)
+  }
+): ScreenViewFactory<WrapperT>
+  where WrapperT : Screen, WrapperT : Wrapper<Screen, WrappedT>, WrappedT : Screen {
   val wrappedFactory = this
 
   return object : ScreenViewFactory<WrapperT> by fromCode(
     buildView = { initialRendering, initialEnvironment, context, container ->
+      val preppedInitialEnvironment = prepEnvironment(initialEnvironment)
+      val preppedContext = prepContext(preppedInitialEnvironment, context)
+
       val wrappedHolder = wrappedFactory.buildView(
         unwrap(initialRendering),
-        initialEnvironment,
-        context,
+        preppedInitialEnvironment,
+        preppedContext,
         container
       )
 
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/ScreenViewFactoryFinder.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/ScreenViewFactoryFinder.kt
index 3b8e4cf97..2e16a92b7 100644
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/ScreenViewFactoryFinder.kt
+++ b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/ScreenViewFactoryFinder.kt
@@ -6,7 +6,6 @@ import com.squareup.workflow1.ui.container.BackStackScreenViewFactory
 import com.squareup.workflow1.ui.container.BodyAndOverlaysContainer
 import com.squareup.workflow1.ui.container.BodyAndOverlaysScreen
 import com.squareup.workflow1.ui.container.EnvironmentScreen
-import com.squareup.workflow1.ui.container.EnvironmentScreenViewFactory
 
 /**
  * [ViewEnvironment] service object used by [Screen.toViewFactory] to find the right
@@ -71,10 +70,15 @@ public interface ScreenViewFactoryFinder {
         BodyAndOverlaysContainer as ScreenViewFactory<ScreenT>
       }
       ?: (rendering as? NamedScreen<*>)?.let {
-        forWrapper<NamedScreen<ScreenT>, ScreenT> { it.wrapped } as ScreenViewFactory<ScreenT>
+        forWrapper<NamedScreen<ScreenT>, ScreenT>() as ScreenViewFactory<ScreenT>
       }
       ?: (rendering as? EnvironmentScreen<*>)?.let {
-        EnvironmentScreenViewFactory<ScreenT>() as ScreenViewFactory<ScreenT>
+        forWrapper<EnvironmentScreen<ScreenT>, ScreenT>(
+          prepEnvironment = { e -> e + rendering.environment },
+          showWrapperScreen = { _, envScreen, environment, showUnwrapped ->
+            showUnwrapped(envScreen.content, environment + envScreen.environment)
+          }
+        ) as ScreenViewFactory<ScreenT>
       }
       ?: throw IllegalArgumentException(
         "A ScreenViewFactory should have been registered to display $rendering, " +
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/AndroidDialogBounds.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/AndroidDialogBounds.kt
index cbb7cd8db..d12f95aad 100644
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/AndroidDialogBounds.kt
+++ b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/AndroidDialogBounds.kt
@@ -1,10 +1,12 @@
 package com.squareup.workflow1.ui.container
 
+import android.annotation.SuppressLint
 import android.app.Dialog
 import android.graphics.Rect
 import android.view.Gravity
 import android.view.View
 import android.view.Window
+import android.view.WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
 import com.squareup.workflow1.ui.ViewEnvironment
 import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
 import kotlinx.coroutines.CoroutineScope
@@ -16,16 +18,19 @@ import kotlinx.coroutines.flow.onEach
 
 /**
  * Updates the size of the [Window] of the receiving [Dialog].
- * [bounds] is expected to be in global display coordinates,
- * e.g. as returned from [View.getGlobalVisibleRect].
+ * [bounds] is expected to be in global screen coordinates,
+ * as returned from [View.getScreenRect].
  *
  * @see OverlayDialogHolder.onUpdateBounds
  */
 @WorkflowUiExperimentalApi
 public fun Dialog.setBounds(bounds: Rect) {
   window?.let {
+    it.addFlags(FLAG_LAYOUT_IN_SCREEN)
     it.attributes = it.attributes.apply {
-      gravity = Gravity.TOP or Gravity.START
+      // Our absolute coordinates are independent from Rtl.
+      @SuppressLint("RtlHardcoded")
+      gravity = Gravity.LEFT or Gravity.TOP // we use absolute coordinates.
       width = bounds.width()
       height = bounds.height()
       x = bounds.left
@@ -34,6 +39,23 @@ public fun Dialog.setBounds(bounds: Rect) {
   }
 }
 
+/**
+ * Returns the bounds of this [View] in the coordinate space of the device
+ * screen, based on [View.getLocationOnScreen] and its reported [width][View.getWidth]
+ * and [height][View.getHeight].
+ */
+@WorkflowUiExperimentalApi
+public fun View.getScreenRect(rect: Rect) {
+  val coordinates = IntArray(2)
+  getLocationOnScreen(coordinates)
+  rect.apply {
+    left = coordinates[0]
+    top = coordinates[1]
+    right = left + width
+    bottom = top + height
+  }
+}
+
 @WorkflowUiExperimentalApi
 internal fun <D : Dialog> D.maintainBounds(
   environment: ViewEnvironment,
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/BackButtonScreen.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/BackButtonScreen.kt
index 13c6e7c86..808bf2dd0 100644
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/BackButtonScreen.kt
+++ b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/BackButtonScreen.kt
@@ -4,15 +4,16 @@ import com.squareup.workflow1.ui.AndroidScreen
 import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.ScreenViewFactory
 import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
+import com.squareup.workflow1.ui.Wrapper
 import com.squareup.workflow1.ui.backPressedHandler
 
 /**
- * Adds optional back button handling to a [wrapped] rendering, possibly overriding that
+ * Adds optional back button handling to a [content] rendering, possibly overriding that
  * the wrapped rendering's own back button handler.
  *
  * @param shadow If `true`, [onBackPressed] is set as the
  * [backPressedHandler][android.view.View.backPressedHandler] after
- * the [wrapped] rendering's view is built / updated, effectively overriding it.
+ * the [content] rendering's view is built / updated, effectively overriding it.
  * If false (the default), [onBackPressed] is set afterward, to allow the wrapped rendering to
  * take precedence if it sets a `backPressedHandler` of its own -- the handler provided
  * here serves as a default.
@@ -22,15 +23,16 @@ import com.squareup.workflow1.ui.backPressedHandler
  * Defaults to `null`.
  */
 @WorkflowUiExperimentalApi
-public class BackButtonScreen<W : Screen>(
-  public val wrapped: W,
+public class BackButtonScreen<C : Screen>(
+  public override val content: C,
   public val shadow: Boolean = false,
   public val onBackPressed: (() -> Unit)? = null
-) : AndroidScreen<BackButtonScreen<W>> {
+) : Wrapper<Screen, C>, AndroidScreen<BackButtonScreen<C>> {
+  override fun <D : Screen> map(transform: (C) -> D): BackButtonScreen<D> =
+    BackButtonScreen(transform(content), shadow, onBackPressed)
 
-  override val viewFactory: ScreenViewFactory<BackButtonScreen<W>> =
+  override val viewFactory: ScreenViewFactory<BackButtonScreen<C>> =
     ScreenViewFactory.forWrapper(
-      unwrap = { it.wrapped },
       showWrapperScreen = { view, backButtonScreen, env, showUnwrapped ->
         if (!backButtonScreen.shadow) {
           // Place our handler before invoking innerShowRendering, so that
@@ -39,8 +41,8 @@ public class BackButtonScreen<W : Screen>(
           view.backPressedHandler = backButtonScreen.onBackPressed
         }
 
-        // Show the wrapped Screen.
-        showUnwrapped(backButtonScreen.wrapped, env)
+        // Show the content Screen.
+        showUnwrapped(backButtonScreen.content, env)
 
         if (backButtonScreen.shadow) {
           // Place our handler after invoking innerShowRendering, so that ours wins.
@@ -48,4 +50,7 @@ public class BackButtonScreen<W : Screen>(
         }
       }
     )
+
+  @Deprecated("Use content", ReplaceWith("content"))
+  public val wrapped: C = content
 }
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreenLegacyViewFactory.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreenLegacyViewFactory.kt
index e568c047b..580faca27 100644
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreenLegacyViewFactory.kt
+++ b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreenLegacyViewFactory.kt
@@ -12,6 +12,6 @@ internal object EnvironmentScreenLegacyViewFactory : ViewFactory<EnvironmentScre
 by DecorativeViewFactory(
   type = EnvironmentScreen::class,
   map = { environmentScreen, inheritedEnvironment ->
-    Pair(environmentScreen.wrapped, environmentScreen.environment + inheritedEnvironment)
+    Pair(environmentScreen.content, environmentScreen.environment + inheritedEnvironment)
   }
 )
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreenViewFactory.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreenViewFactory.kt
deleted file mode 100644
index b13945164..000000000
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreenViewFactory.kt
+++ /dev/null
@@ -1,25 +0,0 @@
-package com.squareup.workflow1.ui.container
-
-import com.squareup.workflow1.ui.Screen
-import com.squareup.workflow1.ui.ScreenViewFactory
-import com.squareup.workflow1.ui.ScreenViewFactory.Companion.fromCode
-import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
-import com.squareup.workflow1.ui.toUnwrappingViewFactory
-import com.squareup.workflow1.ui.toViewFactory
-
-@WorkflowUiExperimentalApi
-internal fun <WrappedT : Screen> EnvironmentScreenViewFactory():
-  ScreenViewFactory<EnvironmentScreen<WrappedT>> {
-  return fromCode { initialEnvScreen, initialEnvironment, context, container ->
-    val mergedInitialEnvironment = initialEnvironment + initialEnvScreen.environment
-
-    initialEnvScreen.wrapped.toViewFactory(mergedInitialEnvironment)
-      .toUnwrappingViewFactory<EnvironmentScreen<WrappedT>, WrappedT>(
-        unwrap = { it.wrapped },
-        showWrapperScreen = { _, envScreen, environment, showUnwrapped ->
-          showUnwrapped(envScreen.wrapped, environment + envScreen.environment)
-        }
-      )
-      .buildView(initialEnvScreen, mergedInitialEnvironment, context, container)
-  }
-}
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/LayeredDialogSessions.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/LayeredDialogSessions.kt
index c95b1f9d7..6065c3e3c 100644
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/LayeredDialogSessions.kt
+++ b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/LayeredDialogSessions.kt
@@ -279,7 +279,7 @@ public class LayeredDialogSessions private constructor(
       superDispatchTouchEvent: (MotionEvent) -> Unit
     ): LayeredDialogSessions {
       val boundsRect = Rect()
-      if (view.isAttachedToWindow) view.getGlobalVisibleRect(boundsRect)
+      if (view.isAttachedToWindow) view.getScreenRect(boundsRect)
       val boundsStateFlow = MutableStateFlow(Rect(boundsRect))
 
       return LayeredDialogSessions(
@@ -326,9 +326,8 @@ public class LayeredDialogSessions private constructor(
         // accordingly.
         val attachStateChangeListener = object : OnAttachStateChangeListener {
           val boundsListener = OnGlobalLayoutListener {
-            if (view.getGlobalVisibleRect(boundsRect) && boundsRect != boundsStateFlow.value) {
-              boundsStateFlow.value = Rect(boundsRect)
-            }
+            view.getScreenRect(boundsRect)
+            if (boundsRect != boundsStateFlow.value) boundsStateFlow.value = Rect(boundsRect)
           }
 
           override fun onViewAttachedToWindow(v: View) {
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/OverlayArea.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/OverlayArea.kt
index 249fbed9a..cbc95a013 100644
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/OverlayArea.kt
+++ b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/OverlayArea.kt
@@ -8,7 +8,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 
 /**
- * Reports the the area of the screen whose events should be blocked by any modal [Overlay],
+ * Reports the area of the screen whose events should be blocked by any modal [Overlay],
  * in the style reported by [View.getGlobalVisibleRect][android.view.View.getGlobalVisibleRect].
  * Expected to be supplied by containers that support [BodyAndOverlaysScreen].
  */
diff --git a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/ScreenOverlayDialogFactory.kt b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/ScreenOverlayDialogFactory.kt
index fde26d881..7f2705ac8 100644
--- a/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/ScreenOverlayDialogFactory.kt
+++ b/workflow-ui/core-android/src/main/java/com/squareup/workflow1/ui/container/ScreenOverlayDialogFactory.kt
@@ -5,6 +5,7 @@ import android.content.Context
 import android.graphics.drawable.ColorDrawable
 import android.util.TypedValue
 import android.view.Window
+import android.view.WindowManager.LayoutParams.FLAG_DIM_BEHIND
 import android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
 import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.ScreenViewHolder
@@ -135,19 +136,22 @@ public open class ScreenOverlayDialogFactory<S : Screen, O : ScreenOverlay<S>>(
       // Note that we always tell Android to make the window non-modal, regardless of our own
       // notion of its modality. Even a modal dialog should only block events within
       // the appropriate bounds, but Android makes them block everywhere.
-      window.setFlags(FLAG_NOT_TOUCH_MODAL, FLAG_NOT_TOUCH_MODAL)
+      window.addFlags(FLAG_NOT_TOUCH_MODAL)
     }
   }
 }
 
 /**
- * The default implementation of [ScreenOverlayDialogFactory.buildDialogWithContent].
+ * Used by the default implementation of [ScreenOverlayDialogFactory.buildDialogWithContent]
+ * to show [contentHolder].
  *
  * - Makes the receiver [non-cancelable][Dialog.setCancelable]
  *
  * - Sets the [background][Window.setBackgroundDrawable] of the receiver's [Window] based
  *   on its theme, if any, or else `null`. (Setting the background to `null` ensures the window
  *   can go full bleed.)
+ *
+ * - Disables dimming.
  */
 @OptIn(WorkflowUiExperimentalApi::class)
 public fun Dialog.setContent(contentHolder: ScreenViewHolder<*>) {
@@ -166,5 +170,8 @@ public fun Dialog.setContent(contentHolder: ScreenViewHolder<*>) {
       // If we don't at least set it to null, the window cannot go full bleed.
       null
     }
-  window!!.setBackgroundDrawable(background)
+  with(window!!) {
+    setBackgroundDrawable(background)
+    clearFlags(FLAG_DIM_BEHIND)
+  }
 }
diff --git a/workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/ScreenViewFactoryTest.kt b/workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/ScreenViewFactoryTest.kt
index ea6cabb3c..4a888559b 100644
--- a/workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/ScreenViewFactoryTest.kt
+++ b/workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/ScreenViewFactoryTest.kt
@@ -1,20 +1,18 @@
-@file:OptIn(WorkflowUiExperimentalApi::class)
-
 package com.squareup.workflow1.ui
 
 import android.content.Context
 import android.view.ViewGroup
 import com.google.common.truth.Truth.assertThat
-import com.squareup.workflow1.ui.ScreenViewFactory.Companion.fromCode
+import com.squareup.workflow1.ui.ScreenViewFactory.Companion.forWrapper
 import com.squareup.workflow1.ui.ViewRegistry.Entry
 import org.junit.Test
 import org.mockito.kotlin.mock
 import kotlin.reflect.KClass
 import kotlin.test.assertFailsWith
 
+@OptIn(WorkflowUiExperimentalApi::class)
 internal class ScreenViewFactoryTest {
 
-  @OptIn(WorkflowUiExperimentalApi::class)
   @Test
   fun missingBindingMessage_isUseful() {
     val emptyReg = object : ViewRegistry {
@@ -67,20 +65,16 @@ internal class ScreenViewFactoryTest {
     val screen = MyWrapper(MyAndroidScreen())
 
     screen.toViewFactory(env).startShowing(screen, env, mock())
-    assertThat(screen.wrapped.viewFactory.built).isTrue()
-    assertThat(screen.wrapped.viewFactory.updated).isTrue()
+    assertThat(screen.content.viewFactory.built).isTrue()
+    assertThat(screen.content.viewFactory.updated).isTrue()
   }
 
   @OptIn(WorkflowUiExperimentalApi::class)
-  private class MyWrapper(
-    val wrapped: MyAndroidScreen
-  ) : AndroidScreen<MyWrapper> {
-    override val viewFactory =
-      fromCode<MyWrapper> { initialScreen, initialEnvironment, _, _ ->
-        wrapped.viewFactory.toUnwrappingViewFactory<MyWrapper, MyAndroidScreen>(
-          unwrap = { wrapped }
-        ).startShowing(initialScreen, initialEnvironment, mock())
-      }
+  private class MyWrapper<C : Screen>(
+    override val content: C
+  ) : Wrapper<Screen, C>, AndroidScreen<MyWrapper<C>> {
+    override fun <D : Screen> map(transform: (C) -> D) = MyWrapper(transform(content))
+    override val viewFactory = forWrapper<MyWrapper<C>, C>()
   }
 
   private class TestViewFactory<T : Screen>(
diff --git a/workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/container/EnvironmentScreenAndroidIntegrationTest.kt b/workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/container/EnvironmentScreenAndroidIntegrationTest.kt
index fd110a050..6030e7a44 100644
--- a/workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/container/EnvironmentScreenAndroidIntegrationTest.kt
+++ b/workflow-ui/core-android/src/test/java/com/squareup/workflow1/ui/container/EnvironmentScreenAndroidIntegrationTest.kt
@@ -1,5 +1,3 @@
-@file:OptIn(WorkflowUiExperimentalApi::class)
-
 package com.squareup.workflow1.ui.container
 
 import com.google.common.truth.Truth.assertThat
@@ -13,6 +11,7 @@ import com.squareup.workflow1.ui.toViewFactory
 import org.junit.Test
 import org.mockito.kotlin.mock
 
+@OptIn(WorkflowUiExperimentalApi::class)
 internal class EnvironmentScreenAndroidIntegrationTest {
   @Test fun mergingWorksForBuild() {
     val altFactory = WrappedFactory()
diff --git a/workflow-ui/core-common/api/core-common.api b/workflow-ui/core-common/api/core-common.api
index 9668794d2..9e843889c 100644
--- a/workflow-ui/core-common/api/core-common.api
+++ b/workflow-ui/core-common/api/core-common.api
@@ -1,7 +1,12 @@
-public final class com/squareup/workflow1/ui/AsScreen : com/squareup/workflow1/ui/Compatible, com/squareup/workflow1/ui/Screen {
+public final class com/squareup/workflow1/ui/AsScreen : com/squareup/workflow1/ui/Screen, com/squareup/workflow1/ui/Wrapper {
 	public fun <init> (Ljava/lang/Object;)V
+	public fun asSequence ()Lkotlin/sequences/Sequence;
 	public fun getCompatibilityKey ()Ljava/lang/String;
+	public fun getContent ()Ljava/lang/Object;
 	public final fun getRendering ()Ljava/lang/Object;
+	public fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/AsScreen;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Container;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Wrapper;
 }
 
 public final class com/squareup/workflow1/ui/AsScreenKt {
@@ -22,6 +27,11 @@ public final class com/squareup/workflow1/ui/CompatibleKt {
 	public static final fun compatible (Ljava/lang/Object;Ljava/lang/Object;)Z
 }
 
+public abstract interface class com/squareup/workflow1/ui/Container {
+	public abstract fun asSequence ()Lkotlin/sequences/Sequence;
+	public abstract fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Container;
+}
+
 public final class com/squareup/workflow1/ui/Named : com/squareup/workflow1/ui/Compatible {
 	public fun <init> (Ljava/lang/Object;Ljava/lang/String;)V
 	public final fun component1 ()Ljava/lang/Object;
@@ -36,17 +46,23 @@ public final class com/squareup/workflow1/ui/Named : com/squareup/workflow1/ui/C
 	public fun toString ()Ljava/lang/String;
 }
 
-public final class com/squareup/workflow1/ui/NamedScreen : com/squareup/workflow1/ui/Compatible, com/squareup/workflow1/ui/Screen {
+public final class com/squareup/workflow1/ui/NamedScreen : com/squareup/workflow1/ui/Screen, com/squareup/workflow1/ui/Wrapper {
 	public fun <init> (Lcom/squareup/workflow1/ui/Screen;Ljava/lang/String;)V
+	public fun asSequence ()Lkotlin/sequences/Sequence;
 	public final fun component1 ()Lcom/squareup/workflow1/ui/Screen;
 	public final fun component2 ()Ljava/lang/String;
 	public final fun copy (Lcom/squareup/workflow1/ui/Screen;Ljava/lang/String;)Lcom/squareup/workflow1/ui/NamedScreen;
 	public static synthetic fun copy$default (Lcom/squareup/workflow1/ui/NamedScreen;Lcom/squareup/workflow1/ui/Screen;Ljava/lang/String;ILjava/lang/Object;)Lcom/squareup/workflow1/ui/NamedScreen;
 	public fun equals (Ljava/lang/Object;)Z
 	public fun getCompatibilityKey ()Ljava/lang/String;
+	public fun getContent ()Lcom/squareup/workflow1/ui/Screen;
+	public synthetic fun getContent ()Ljava/lang/Object;
 	public final fun getName ()Ljava/lang/String;
 	public final fun getWrapped ()Lcom/squareup/workflow1/ui/Screen;
 	public fun hashCode ()I
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Container;
+	public fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/NamedScreen;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Wrapper;
 	public fun toString ()Ljava/lang/String;
 }
 
@@ -120,6 +136,18 @@ public final class com/squareup/workflow1/ui/ViewRegistryKt {
 public abstract interface annotation class com/squareup/workflow1/ui/WorkflowUiExperimentalApi : java/lang/annotation/Annotation {
 }
 
+public abstract interface class com/squareup/workflow1/ui/Wrapper : com/squareup/workflow1/ui/Compatible, com/squareup/workflow1/ui/Container {
+	public abstract fun asSequence ()Lkotlin/sequences/Sequence;
+	public abstract fun getCompatibilityKey ()Ljava/lang/String;
+	public abstract fun getContent ()Ljava/lang/Object;
+	public abstract fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Wrapper;
+}
+
+public final class com/squareup/workflow1/ui/Wrapper$DefaultImpls {
+	public static fun asSequence (Lcom/squareup/workflow1/ui/Wrapper;)Lkotlin/sequences/Sequence;
+	public static fun getCompatibilityKey (Lcom/squareup/workflow1/ui/Wrapper;)Ljava/lang/String;
+}
+
 public final class com/squareup/workflow1/ui/container/AlertOverlay : com/squareup/workflow1/ui/container/ModalOverlay {
 	public fun <init> (Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;)V
 	public synthetic fun <init> (Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;ZLkotlin/jvm/functions/Function1;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
@@ -166,16 +194,18 @@ public final class com/squareup/workflow1/ui/container/AlertOverlay$Event$Cancel
 	public static final field INSTANCE Lcom/squareup/workflow1/ui/container/AlertOverlay$Event$Canceled;
 }
 
-public final class com/squareup/workflow1/ui/container/BackStackScreen : com/squareup/workflow1/ui/Screen {
+public final class com/squareup/workflow1/ui/container/BackStackScreen : com/squareup/workflow1/ui/Container, com/squareup/workflow1/ui/Screen {
 	public fun <init> (Lcom/squareup/workflow1/ui/Screen;Ljava/util/List;)V
 	public fun <init> (Lcom/squareup/workflow1/ui/Screen;[Lcom/squareup/workflow1/ui/Screen;)V
+	public fun asSequence ()Lkotlin/sequences/Sequence;
 	public fun equals (Ljava/lang/Object;)Z
 	public final fun get (I)Lcom/squareup/workflow1/ui/Screen;
 	public final fun getBackStack ()Ljava/util/List;
 	public final fun getFrames ()Ljava/util/List;
 	public final fun getTop ()Lcom/squareup/workflow1/ui/Screen;
 	public fun hashCode ()I
-	public final fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/BackStackScreen;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Container;
+	public fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/BackStackScreen;
 	public final fun mapIndexed (Lkotlin/jvm/functions/Function2;)Lcom/squareup/workflow1/ui/container/BackStackScreen;
 	public final fun plus (Lcom/squareup/workflow1/ui/container/BackStackScreen;)Lcom/squareup/workflow1/ui/container/BackStackScreen;
 	public fun toString ()Ljava/lang/String;
@@ -186,22 +216,30 @@ public final class com/squareup/workflow1/ui/container/BackStackScreenKt {
 	public static final fun toBackStackScreenOrNull (Ljava/util/List;)Lcom/squareup/workflow1/ui/container/BackStackScreen;
 }
 
-public final class com/squareup/workflow1/ui/container/BodyAndOverlaysScreen : com/squareup/workflow1/ui/Screen {
-	public fun <init> (Lcom/squareup/workflow1/ui/Screen;Ljava/util/List;)V
-	public synthetic fun <init> (Lcom/squareup/workflow1/ui/Screen;Ljava/util/List;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+public final class com/squareup/workflow1/ui/container/BodyAndOverlaysScreen : com/squareup/workflow1/ui/Compatible, com/squareup/workflow1/ui/Screen {
+	public fun <init> (Lcom/squareup/workflow1/ui/Screen;Ljava/util/List;Ljava/lang/String;)V
+	public synthetic fun <init> (Lcom/squareup/workflow1/ui/Screen;Ljava/util/List;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public fun <init> (Lcom/squareup/workflow1/ui/Screen;[Lcom/squareup/workflow1/ui/container/Overlay;)V
 	public final fun getBody ()Lcom/squareup/workflow1/ui/Screen;
+	public fun getCompatibilityKey ()Ljava/lang/String;
+	public final fun getName ()Ljava/lang/String;
 	public final fun getOverlays ()Ljava/util/List;
 	public final fun mapBody (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/BodyAndOverlaysScreen;
 	public final fun mapModals (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/BodyAndOverlaysScreen;
 }
 
-public final class com/squareup/workflow1/ui/container/EnvironmentScreen : com/squareup/workflow1/ui/Compatible, com/squareup/workflow1/ui/Screen {
+public final class com/squareup/workflow1/ui/container/EnvironmentScreen : com/squareup/workflow1/ui/Screen, com/squareup/workflow1/ui/Wrapper {
 	public fun <init> (Lcom/squareup/workflow1/ui/Screen;Lcom/squareup/workflow1/ui/ViewEnvironment;)V
 	public synthetic fun <init> (Lcom/squareup/workflow1/ui/Screen;Lcom/squareup/workflow1/ui/ViewEnvironment;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun asSequence ()Lkotlin/sequences/Sequence;
 	public fun getCompatibilityKey ()Ljava/lang/String;
+	public fun getContent ()Lcom/squareup/workflow1/ui/Screen;
+	public synthetic fun getContent ()Ljava/lang/Object;
 	public final fun getEnvironment ()Lcom/squareup/workflow1/ui/ViewEnvironment;
 	public final fun getWrapped ()Lcom/squareup/workflow1/ui/Screen;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Container;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Wrapper;
+	public fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/EnvironmentScreen;
 }
 
 public final class com/squareup/workflow1/ui/container/EnvironmentScreenKt {
@@ -212,8 +250,14 @@ public final class com/squareup/workflow1/ui/container/EnvironmentScreenKt {
 
 public final class com/squareup/workflow1/ui/container/FullScreenOverlay : com/squareup/workflow1/ui/container/ScreenOverlay {
 	public fun <init> (Lcom/squareup/workflow1/ui/Screen;)V
+	public fun asSequence ()Lkotlin/sequences/Sequence;
 	public fun getCompatibilityKey ()Ljava/lang/String;
 	public fun getContent ()Lcom/squareup/workflow1/ui/Screen;
+	public synthetic fun getContent ()Ljava/lang/Object;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Container;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/Wrapper;
+	public fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/FullScreenOverlay;
+	public synthetic fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/ScreenOverlay;
 }
 
 public abstract interface class com/squareup/workflow1/ui/container/ModalOverlay : com/squareup/workflow1/ui/container/Overlay {
@@ -222,12 +266,13 @@ public abstract interface class com/squareup/workflow1/ui/container/ModalOverlay
 public abstract interface class com/squareup/workflow1/ui/container/Overlay {
 }
 
-public abstract interface class com/squareup/workflow1/ui/container/ScreenOverlay : com/squareup/workflow1/ui/Compatible, com/squareup/workflow1/ui/container/Overlay {
-	public abstract fun getCompatibilityKey ()Ljava/lang/String;
+public abstract interface class com/squareup/workflow1/ui/container/ScreenOverlay : com/squareup/workflow1/ui/Wrapper, com/squareup/workflow1/ui/container/Overlay {
 	public abstract fun getContent ()Lcom/squareup/workflow1/ui/Screen;
+	public abstract fun map (Lkotlin/jvm/functions/Function1;)Lcom/squareup/workflow1/ui/container/ScreenOverlay;
 }
 
 public final class com/squareup/workflow1/ui/container/ScreenOverlay$DefaultImpls {
+	public static fun asSequence (Lcom/squareup/workflow1/ui/container/ScreenOverlay;)Lkotlin/sequences/Sequence;
 	public static fun getCompatibilityKey (Lcom/squareup/workflow1/ui/container/ScreenOverlay;)Ljava/lang/String;
 }
 
diff --git a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/AsScreen.kt b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/AsScreen.kt
index 6a7f8cc1f..72926206b 100644
--- a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/AsScreen.kt
+++ b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/AsScreen.kt
@@ -6,17 +6,20 @@ package com.squareup.workflow1.ui
  * `Overlay` interfaces, and will be deprecated and deleted sooner or later.
  */
 @WorkflowUiExperimentalApi
-public class AsScreen<W : Any>(
-  public val rendering: W
-) : Screen, Compatible {
+public class AsScreen<C : Any>(
+  override val content: C
+) : Screen, Wrapper<Any, C> {
   init {
-    check(rendering !is Screen) {
-      "AsScreen is for converting non-Screen renderings, it should not wrap Screen $rendering."
+    check(content !is Screen) {
+      "AsScreen is for converting non-Screen renderings, it should not wrap Screen $content."
     }
   }
 
-  override val compatibilityKey: String
-    get() = Compatible.keyFor(rendering, "AsScreen")
+  @Deprecated("Use content", ReplaceWith("content"))
+  public val rendering: C = content
+
+  override fun <D : Any> map(transform: (C) -> D): AsScreen<D> =
+    AsScreen(transform(content))
 }
 
 /**
diff --git a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/Container.kt b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/Container.kt
new file mode 100644
index 000000000..92100388b
--- /dev/null
+++ b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/Container.kt
@@ -0,0 +1,74 @@
+package com.squareup.workflow1.ui
+
+import com.squareup.workflow1.ui.Compatible.Companion.keyFor
+
+/**
+ * A rendering type comprised of a set of other renderings.
+ *
+ * Why two parameter types? The separate [BaseT] type allows implementations
+ * and sub-interfaces to constrain the types that [map] is allowed to
+ * transform [ContentT] to. E.g., it allows `FooWrapper<S: Screen>` to declare
+ * that [map] is only able to transform `S` to other types of `Screen`.
+ *
+ * @param BaseT the invariant base type of the contents of such a container,
+ * usually [Screen] or [Overlay][com.squareup.workflow1.ui.container.Overlay].
+ * It is common for the [Container] itself to implement [BaseT], but that is
+ * not a requirement. E.g., [ScreenOverlay][com.squareup.workflow1.ui.container.ScreenOverlay]
+ * is an [Overlay][com.squareup.workflow1.ui.container.Overlay], but it
+ * wraps a [Screen].
+ *
+ * @param ContentT the specific subtype of [BaseT] collected by this [Container].
+ */
+@WorkflowUiExperimentalApi
+public interface Container<BaseT, out ContentT : BaseT> {
+  public fun asSequence(): Sequence<ContentT>
+
+  /**
+   * Returns a [Container] with the [transform]ed contents of the receiver.
+   * It is expected that an implementation will take advantage of covariance
+   * to declare its own type as the return type, rather than plain old [Container].
+   * This requirement is not enforced because recursive generics are a fussy nuisance.
+   *
+   * For example, suppose we want to create `LoggingScreen`, one that wraps any
+   * other screen to add some logging calls. Its implementation of this method
+   * would be expected to have a return type of `LoggingScreen` rather than `Container`:
+   *
+   *    override fun <D : Screen> map(transform: (C) -> D): LoggingScreen<D> =
+   *      LoggingScreen(transform(content))
+   *
+   * By requiring all [Container] types to implement [map], we ensure that their
+   * contents can be repackaged in interesting ways, e.g.:
+   *
+   *    val childBackStackScreen = renderChild(childWorkflow) { ... }
+   *    val loggingBackStackScreen = childBackStackScreen.map { LoggingScreen(it) }
+   */
+  public fun <ContentU : BaseT> map(transform: (ContentT) -> ContentU): Container<BaseT, ContentU>
+}
+
+/**
+ * A [Container] rendering that wraps exactly one other rendering, its [content]. These are
+ * typically used to "add value" to the [content], e.g. an
+ * [EnvironmentScreen][com.squareup.workflow1.ui.container.EnvironmentScreen] that allows
+ * changes to be made to the [ViewEnvironment].
+ *
+ * Usually a [Wrapper] is [Compatible] only with others of the same type with
+ * [Compatible] [content]. In aid of that, this interface extends [Compatible] and
+ * provides a convenient default implementation of [compatibilityKey].
+ */
+@WorkflowUiExperimentalApi
+public interface Wrapper<BaseT : Any, ContentT : BaseT> : Container<BaseT, ContentT>, Compatible {
+  public val content: ContentT
+
+  /**
+   * Default implementation makes this [Wrapper] compatible with others of the same type,
+   * and which wrap compatible [content].
+   */
+  public override val compatibilityKey: String
+    get() = keyFor(content, this::class.simpleName ?: "Wrapper")
+
+  public override fun asSequence(): Sequence<ContentT> = sequenceOf(content)
+
+  public override fun <ContentU : BaseT> map(
+    transform: (ContentT) -> ContentU
+  ): Wrapper<BaseT, ContentU>
+}
diff --git a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/NamedScreen.kt b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/NamedScreen.kt
index c35160977..519c87a8c 100644
--- a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/NamedScreen.kt
+++ b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/NamedScreen.kt
@@ -3,20 +3,26 @@ package com.squareup.workflow1.ui
 /**
  * Allows [Screen] renderings that do not implement [Compatible] themselves to be distinguished
  * by more than just their type. Instances are [compatible] if they have the same name
- * and have [compatible] [wrapped] fields.
+ * and have [compatible] [content] fields.
  *
  * UI kits are expected to provide handling for this class by default.
  */
 @WorkflowUiExperimentalApi
-public data class NamedScreen<W : Screen>(
-  val wrapped: W,
+public data class NamedScreen<C : Screen>(
+  override val content: C,
   val name: String
-) : Screen, Compatible {
+) : Screen, Wrapper<Screen, C> {
   init {
     require(name.isNotBlank()) { "name must not be blank." }
   }
 
-  override val compatibilityKey: String = Compatible.keyFor(wrapped, "NamedScreen($name)")
+  override val compatibilityKey: String = Compatible.keyFor(content, "NamedScreen($name)")
+
+  @Deprecated("Use content", ReplaceWith("content"))
+  public val wrapped: C = content
+
+  override fun <D : Screen> map(transform: (C) -> D): NamedScreen<D> =
+    NamedScreen(transform(content), name)
 
   override fun toString(): String {
     return "${super.toString()}: $compatibilityKey"
diff --git a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/BackStackScreen.kt b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/BackStackScreen.kt
index aa236752d..bb8815eee 100644
--- a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/BackStackScreen.kt
+++ b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/BackStackScreen.kt
@@ -1,5 +1,6 @@
 package com.squareup.workflow1.ui.container
 
+import com.squareup.workflow1.ui.Container
 import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
 
@@ -19,7 +20,7 @@ import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
 public class BackStackScreen<StackedT : Screen>(
   bottom: StackedT,
   rest: List<StackedT>
-) : Screen {
+) : Screen, Container<Screen, StackedT> {
   /**
    * Creates a screen with elements listed from the [bottom] to the top.
    */
@@ -28,6 +29,8 @@ public class BackStackScreen<StackedT : Screen>(
     vararg rest: StackedT
   ) : this(bottom, rest.toList())
 
+  override fun asSequence(): Sequence<StackedT> = frames.asSequence()
+
   public val frames: List<StackedT> = listOf(bottom) + rest
 
   /**
@@ -50,9 +53,10 @@ public class BackStackScreen<StackedT : Screen>(
     }
   }
 
-  public fun <R : Screen> map(transform: (StackedT) -> R): BackStackScreen<R> {
-    return frames.map(transform)
-      .toBackStackScreen()
+  public override fun <StackedU : Screen> map(
+    transform: (StackedT) -> StackedU
+  ): BackStackScreen<StackedU> {
+    return frames.map(transform).toBackStackScreen()
   }
 
   public fun <R : Screen> mapIndexed(transform: (index: Int, StackedT) -> R): BackStackScreen<R> {
diff --git a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/BodyAndOverlaysScreen.kt b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/BodyAndOverlaysScreen.kt
index 3e0a92a1a..171f1dd83 100644
--- a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/BodyAndOverlaysScreen.kt
+++ b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/BodyAndOverlaysScreen.kt
@@ -1,5 +1,7 @@
 package com.squareup.workflow1.ui.container
 
+import com.squareup.workflow1.ui.Compatible
+import com.squareup.workflow1.ui.Compatible.Companion.keyFor
 import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
 
@@ -10,12 +12,20 @@ import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
  * events -- touch, keyboard, etc.
  *
  * UI kits are expected to provide handling for this class by default.
+ *
+ * @param name included in the [compatibilityKey] of this screen, for ease
+ * of nesting -- on Android, each BodyAndOverlaysScreen view state persistence
+ * support requires each BodyAndOverlaysScreen in a hierarchy to have a
+ * unique key
  */
 @WorkflowUiExperimentalApi
 public class BodyAndOverlaysScreen<B : Screen, O : Overlay>(
   public val body: B,
-  public val overlays: List<O> = emptyList()
-) : Screen {
+  public val overlays: List<O> = emptyList(),
+  public val name: String = ""
+) : Screen, Compatible {
+  override val compatibilityKey: String = keyFor(this, name)
+
   public constructor(
     body: B,
     vararg modals: O
diff --git a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreen.kt b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreen.kt
index 89aef75fa..6b05343e2 100644
--- a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreen.kt
+++ b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/EnvironmentScreen.kt
@@ -1,14 +1,14 @@
 package com.squareup.workflow1.ui.container
 
-import com.squareup.workflow1.ui.Compatible
 import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.ViewEnvironment
 import com.squareup.workflow1.ui.ViewRegistry
 import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
+import com.squareup.workflow1.ui.Wrapper
 import com.squareup.workflow1.ui.plus
 
 /**
- * Pairs a [wrapped] rendering with a [environment] to support its display.
+ * Pairs a [content] rendering with a [environment] to support its display.
  * Typically the rendering type (`RenderingT`) of the root of a UI workflow,
  * but can be used at any point to modify the [ViewEnvironment] received from
  * a parent view.
@@ -16,15 +16,15 @@ import com.squareup.workflow1.ui.plus
  * UI kits are expected to provide handling for this class by default.
  */
 @WorkflowUiExperimentalApi
-public class EnvironmentScreen<V : Screen>(
-  public val wrapped: V,
+public class EnvironmentScreen<C : Screen>(
+  public override val content: C,
   public val environment: ViewEnvironment = ViewEnvironment.EMPTY
-) : Compatible, Screen {
-  /**
-   * Ensures that we make the decision to update or replace the root view based on
-   * the wrapped [wrapped].
-   */
-  override val compatibilityKey: String = Compatible.keyFor(wrapped, "EnvironmentScreen")
+) : Wrapper<Screen, C>, Screen {
+  override fun <D : Screen> map(transform: (C) -> D): EnvironmentScreen<D> =
+    EnvironmentScreen(transform(content), environment)
+
+  @Deprecated("Use content", ReplaceWith("content"))
+  public val wrapped: C = content
 }
 
 /**
@@ -55,7 +55,7 @@ public fun Screen.withEnvironment(
       if (environment.map.isEmpty()) {
         this
       } else {
-        EnvironmentScreen(wrapped, this.environment + environment)
+        EnvironmentScreen(content, this.environment + environment)
       }
     }
     else -> EnvironmentScreen(this, environment)
diff --git a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/FullScreenOverlay.kt b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/FullScreenOverlay.kt
index e0130762a..a6b8f41bf 100644
--- a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/FullScreenOverlay.kt
+++ b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/FullScreenOverlay.kt
@@ -9,6 +9,9 @@ import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
  * UI kits are expected to provide handling for this class by default.
  */
 @WorkflowUiExperimentalApi
-public class FullScreenOverlay<ContentT : Screen>(
-  public override val content: ContentT
-) : ScreenOverlay<ContentT>
+public class FullScreenOverlay<C : Screen>(
+  public override val content: C
+) : ScreenOverlay<C> {
+  override fun <D : Screen> map(transform: (C) -> D): FullScreenOverlay<D> =
+    FullScreenOverlay(transform(content))
+}
diff --git a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/ScreenOverlay.kt b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/ScreenOverlay.kt
index 23a459ae2..7d7814d72 100644
--- a/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/ScreenOverlay.kt
+++ b/workflow-ui/core-common/src/main/java/com/squareup/workflow1/ui/container/ScreenOverlay.kt
@@ -1,17 +1,15 @@
 package com.squareup.workflow1.ui.container
 
-import com.squareup.workflow1.ui.Compatible
-import com.squareup.workflow1.ui.Compatible.Companion.keyFor
 import com.squareup.workflow1.ui.Screen
 import com.squareup.workflow1.ui.WorkflowUiExperimentalApi
+import com.squareup.workflow1.ui.Wrapper
 
 /**
  * An [Overlay] built around a root [content] [Screen].
  */
 @WorkflowUiExperimentalApi
-public interface ScreenOverlay<ContentT : Screen> : Overlay, Compatible {
-  public val content: ContentT
+public interface ScreenOverlay<ContentT : Screen> : Overlay, Wrapper<Screen, ContentT> {
+  public override val content: ContentT
 
-  override val compatibilityKey: String
-    get() = keyFor(content, this::class.simpleName ?: ScreenOverlay::class.simpleName!!)
+  override fun <ContentU : Screen> map(transform: (ContentT) -> ContentU): ScreenOverlay<ContentU>
 }
diff --git a/workflow-ui/core-common/src/test/java/com/squareup/workflow1/ui/NamedScreenTest.kt b/workflow-ui/core-common/src/test/java/com/squareup/workflow1/ui/NamedScreenTest.kt
index 7b1ebac56..602f56edf 100644
--- a/workflow-ui/core-common/src/test/java/com/squareup/workflow1/ui/NamedScreenTest.kt
+++ b/workflow-ui/core-common/src/test/java/com/squareup/workflow1/ui/NamedScreenTest.kt
@@ -5,7 +5,6 @@ import org.junit.Test
 
 // If you try to replace isTrue() with isTrue compilation fails.
 @OptIn(WorkflowUiExperimentalApi::class)
-@Suppress("UsePropertyAccessSyntax")
 internal class NamedScreenTest {
   object Whut : Screen
   object Hey : Screen
diff --git a/workflow-ui/internal-testing-android/src/main/java/com/squareup/workflow1/ui/internal/test/WorkflowUiTestActivity.kt b/workflow-ui/internal-testing-android/src/main/java/com/squareup/workflow1/ui/internal/test/WorkflowUiTestActivity.kt
index acdf72d60..aacf46fa7 100644
--- a/workflow-ui/internal-testing-android/src/main/java/com/squareup/workflow1/ui/internal/test/WorkflowUiTestActivity.kt
+++ b/workflow-ui/internal-testing-android/src/main/java/com/squareup/workflow1/ui/internal/test/WorkflowUiTestActivity.kt
@@ -101,7 +101,7 @@ public open class WorkflowUiTestActivity : AppCompatActivity() {
   public fun setRendering(rendering: Screen): View {
     lastRendering = rendering
     val named = NamedScreen(
-      wrapped = rendering,
+      content = rendering,
       name = renderingCounter.toString()
     )
     rootStub.show(named, viewEnvironment)
diff --git a/workflow-ui/radiography/src/main/java/com/squareup/workflow1/ui/radiography/WorkflowViewRenderer.kt b/workflow-ui/radiography/src/main/java/com/squareup/workflow1/ui/radiography/WorkflowViewRenderer.kt
index b3643a301..43c0e4987 100644
--- a/workflow-ui/radiography/src/main/java/com/squareup/workflow1/ui/radiography/WorkflowViewRenderer.kt
+++ b/workflow-ui/radiography/src/main/java/com/squareup/workflow1/ui/radiography/WorkflowViewRenderer.kt
@@ -37,7 +37,7 @@ private object WorkflowViewRendererImpl : ViewStateRenderer {
 
   private fun AttributeAppendable.renderRendering(rendering: Any) {
     val actualRendering = (rendering as? Named<*>)?.wrapped
-      ?: (rendering as? NamedScreen<*>)?.wrapped
+      ?: (rendering as? NamedScreen<*>)?.content
       ?: rendering
     append("workflow-rendering-type:${actualRendering::class.java.name}")