peachsim 0.1.939 → 0.1.1399

package/src/bundle-channel.mjs

@@ -2,11 +2,33 @@
 import { createHash } from 'node:crypto'
 import { Script } from 'node:vm'
 import { terminateProcessGroup } from '../../contrast/src/runtime/process-group'
+import { isLoopbackHost } from './backend-origin'
+import { insertExpoKotlinFooter } from './expoKotlinContract'
 import { insertExpoSwiftFooter } from './expoSwiftContract'
 
 const digest = (bytes) => createHash('sha256').update(bytes).digest('hex')
 const segment = /^[a-zA-Z0-9._-]+$/
 
+// where a dev server asset location's files live in a release. metro names a
+// file outside the project root by an `unstable_path` query.
+function packagedAssetDirectory(location) {
+  const parsed = new URL(location, 'https://packaged.invalid')
+  if (parsed.origin !== 'https://packaged.invalid')
+    throw new Error(`non-packaged asset location: ${location}`)
+  const outside = parsed.searchParams.get('unstable_path')
+  if (outside === null) return parsed.pathname.replace(/^\/+/, '')
+  return `assets/${outside.replace(/^\.\//, '').replace(/\.\.\//g, '_')}`
+}
+
+// each platform publishes its own channel. ios keeps the original deployed
+// keys, which home screen configs already name.
+const channelKey = (platform) =>
+  platform === 'ios' ? 'peach/channels/prod' : `peach/channels/${platform}/prod`
+const nativeAssetPath = {
+  ios: /^__peach\/(swift|swift-icu)\/[a-f0-9]{64}(\.wasm)?$/,
+  android: /^__peach\/kotlin\/[a-f0-9]+\/[A-Za-z0-9._-]+\.(mjs|wasm)$/,
+}
+
 export function prepareBundleChannel({
   prefix,
   publicOrigin,
@@ -14,16 +36,18 @@ export function prepareBundleChannel({
   runtimeVersion,
   name,
   icon,
-  bundle,
-  assets,
-  expoSwift = null,
+  platforms,
 }) {
   if (!/^[a-f0-9]{40}$/.test(sourceSha) || !/^\d+$/.test(runtimeVersion)) {
     throw new Error('invalid bundle channel source identity')
   }
   const origin = new URL(publicOrigin)
   if (
-    origin.protocol !== 'https:' ||
+    // a loopback origin serves local release proofs
+    !(
+      origin.protocol === 'https:' ||
+      (origin.protocol === 'http:' && isLoopbackHost(origin.hostname))
+    ) ||
     origin.pathname !== '/' ||
     origin.search ||
     origin.hash ||
@@ -37,6 +61,40 @@ export function prepareBundleChannel({
   }
   if (!icon.subarray(0, 8).equals(Buffer.from('89504e470d0a1a0a', 'hex')))
     throw new Error('bundle channel icon must be PNG')
+  if (!platforms.length) throw new Error('bundle channel has no platforms')
+  if (new Set(platforms.map((p) => p.platform)).size !== platforms.length)
+    throw new Error('bundle channel repeats a platform')
+  const channels = platforms.map((snapshot) =>
+    prepareChannel({
+      prefix,
+      origin,
+      sourceSha,
+      runtimeVersion,
+      name,
+      icon,
+      ...snapshot,
+    }),
+  )
+  return { prefix, origin: origin.origin, channels }
+}
+
+function prepareChannel({
+  prefix,
+  origin,
+  sourceSha,
+  runtimeVersion,
+  name,
+  icon,
+  platform,
+  bundle,
+  assets,
+  expoSwift = null,
+  expoKotlin = null,
+}) {
+  if (!(platform in nativeAssetPath)) throw new Error(`unknown platform: ${platform}`)
+  const native = platform === 'ios' ? expoSwift : expoKotlin
+  if ((platform === 'ios' ? expoKotlin : expoSwift) !== null)
+    throw new Error(`${platform} bundle carries another platform's native modules`)
   const files = new Map()
   for (const asset of assets) {
     if (
@@ -50,9 +108,9 @@ export function prepareBundleChannel({
     if (files.has(asset.path)) throw new Error(`duplicate packaged asset: ${asset.path}`)
     files.set(asset.path, asset.bytes)
   }
-  for (const asset of expoSwift?.assets ?? []) {
-    if (!/^__peach\/(swift|swift-icu)\/[a-f0-9]{64}(\.wasm)?$/.test(asset.path))
-      throw new Error(`invalid Swift artifact path: ${asset.path}`)
+  for (const asset of native?.assets ?? []) {
+    if (!nativeAssetPath[platform].test(asset.path))
+      throw new Error(`invalid native artifact path: ${asset.path}`)
     if (files.has(asset.path)) throw new Error(`duplicate packaged asset: ${asset.path}`)
     files.set(asset.path, asset.bytes)
   }
@@ -64,7 +122,7 @@ export function prepareBundleChannel({
   )) {
     identity.update(JSON.stringify([path, digest(bytes)]))
   }
-  if (expoSwift) identity.update(JSON.stringify(expoSwift.metadata))
+  if (native) identity.update(JSON.stringify(native.metadata))
   const releaseKey = `${prefix}/peach/releases/${identity.digest('hex')}`
   const assetBaseUrl = `${origin.origin}/${releaseKey}/`
   const directories = new Set(
@@ -76,12 +134,7 @@ export function prepareBundleChannel({
     /("?httpServerLocation"?\s*:\s*)(?:"((?:[^"\\]|\\.)*)"|`([^`\\$]*)`)/g,
     (match, property, quoted, template) => {
       const location = quoted === undefined ? template : JSON.parse(`"${quoted}"`)
-      const parsed = new URL(location, 'https://packaged.invalid')
-      if (parsed.origin !== 'https://packaged.invalid')
-        throw new Error(`non-packaged asset location: ${location}`)
-      const path = (parsed.searchParams.get('unstable_path') ?? parsed.pathname)
-        .replace(/^\/+/, '')
-        .replace(/\.\.\//g, '_')
+      const path = packagedAssetDirectory(location)
       if (!directories.has(path)) {
         throw new Error(`bundle asset location has no packaged files: ${location}`)
       }
@@ -91,25 +144,38 @@ export function prepareBundleChannel({
   )
   if (assets.length && !locations)
     throw new Error('bundle has packaged files but no asset metadata')
+  const release = (url) => new URL(url.replace(/^\//, ''), assetBaseUrl).href
   let nativeMetadata = null
   if (expoSwift) {
     nativeMetadata = {
-      ...expoSwift.metadata,
-      modules: expoSwift.metadata.modules.map((artifact) => ({
-        ...artifact,
-        url: new URL(artifact.url.replace(/^\//, ''), assetBaseUrl).href,
-        icuUrl: artifact.icuUrl.startsWith('/')
-          ? new URL(artifact.icuUrl.slice(1), assetBaseUrl).href
-          : artifact.icuUrl,
-      })),
+      expoSwift: {
+        ...expoSwift.metadata,
+        modules: expoSwift.metadata.modules.map((artifact) => ({
+          ...artifact,
+          url: release(artifact.url),
+          icuUrl: artifact.icuUrl.startsWith('/')
+            ? release(artifact.icuUrl)
+            : artifact.icuUrl,
+        })),
+      },
     }
-    source = insertExpoSwiftFooter(source, nativeMetadata)
+    source = insertExpoSwiftFooter(source, nativeMetadata.expoSwift)
+  }
+  if (expoKotlin) {
+    const { module } = expoKotlin.metadata
+    nativeMetadata = {
+      expoKotlin: {
+        ...expoKotlin.metadata,
+        module: module && { ...module, url: release(module.url) },
+      },
+    }
+    source = insertExpoKotlinFooter(source, nativeMetadata.expoKotlin)
   }
   new Script(source, { filename: 'peach-release-bundle.js' })
   const bundleBytes = Buffer.from(source)
   const metadata = {
     schemaVersion: 1,
-    ...(nativeMetadata ? { expoSwift: nativeMetadata } : {}),
+    ...nativeMetadata,
     channel: 'prod',
     name,
     iconUrl: `${assetBaseUrl}icon.png`,
@@ -117,7 +183,7 @@ export function prepareBundleChannel({
     assetBaseUrl,
     sourceSha,
     runtimeVersion,
-    platform: 'ios',
+    platform,
     bundleHash: digest(bundleBytes),
   }
   const objects = [
@@ -131,7 +197,7 @@ export function prepareBundleChannel({
       key: `${releaseKey}/${path}`,
       bytes,
       contentType:
-        expoSwift?.assets.find((asset) => asset.path === path)?.contentType ??
+        native?.assets.find((asset) => asset.path === path)?.contentType ??
         {
           png: 'image/png',
           jpg: 'image/jpeg',
@@ -145,11 +211,11 @@ export function prepareBundleChannel({
         'application/octet-stream',
     })),
   ]
-  return { prefix, origin: origin.origin, metadata, objects }
+  return { platform, key: `${prefix}/${channelKey(platform)}`, metadata, objects }
 }
 
 export async function publishBundleChannel(release, { put, fetchObject = fetch }) {
-  // prove every immutable object is downloadable before changing the channel.
+  // prove every immutable object is downloadable before changing a channel.
   async function uploadVerified(object, cacheControl) {
     await put(object.key, object.bytes, object.contentType, cacheControl)
     const response = await fetchObject(`${release.origin}/${object.key}`)
@@ -159,41 +225,110 @@ export async function publishBundleChannel(release, { put, fetchObject = fetch }
     if (digest(bytes) !== digest(object.bytes))
       throw new Error(`bundle channel download mismatch: ${object.key}`)
   }
-  for (const object of release.objects) await uploadVerified(object)
-  const bundle = release.objects[0]
-  await uploadVerified(
-    { ...bundle, key: `${release.prefix}/peach/channels/prod.js` },
-    'no-store',
-  )
-  await put(
-    `${release.prefix}/peach/channels/prod.json`,
-    Buffer.from(JSON.stringify(release.metadata)),
-    'application/json',
-    'no-store',
-  )
-  const response = await fetchObject(
-    `${release.origin}/${release.prefix}/peach/channels/prod.json`,
-    { cache: 'no-store' },
-  )
-  if (
-    !response.ok ||
-    JSON.stringify(await response.json()) !== JSON.stringify(release.metadata)
-  ) {
-    throw new Error('published bundle channel metadata did not match')
+  for (const channel of release.channels)
+    for (const object of channel.objects) await uploadVerified(object)
+  for (const channel of release.channels) {
+    await uploadVerified({ ...channel.objects[0], key: `${channel.key}.js` }, 'no-store')
+    await put(
+      `${channel.key}.json`,
+      Buffer.from(JSON.stringify(channel.metadata)),
+      'application/json',
+      'no-store',
+    )
+    const response = await fetchObject(`${release.origin}/${channel.key}.json`, {
+      cache: 'no-store',
+    })
+    if (
+      !response.ok ||
+      JSON.stringify(await response.json()) !== JSON.stringify(channel.metadata)
+    ) {
+      throw new Error(
+        `published ${channel.platform} bundle channel metadata did not match`,
+      )
+    }
+    console.log(
+      `[ota] Peach ${channel.platform} prod channel: ${release.origin}/${channel.key}.json`,
+    )
   }
-  console.log(
-    `[ota] Peach prod channel: ${release.origin}/${release.prefix}/peach/channels/prod.json`,
-  )
 }
 
-// peach boots a One app from the dev server's bundle: it carries the module
-// graph peach maps native seams by, which a release build erases. snapshot it
-// from a private dev server and package the files its assets register.
+// peach boots an app from the dev server's bundle: it carries the module graph
+// peach maps native seams by, which a release build erases. snapshot each
+// platform's bundle from a running dev server and package the files its
+// assets register, with the app's local Expo native modules for that platform.
+export async function snapshotDevServerBundles(
+  origin,
+  projectRoot,
+  { platforms = ['ios', 'android'], assertRunning = () => {} } = {},
+) {
+  const { readFileSync } = await import('node:fs')
+  const { basename } = await import('node:path')
+  const snapshots = []
+  for (const platform of platforms) {
+    const url = `${origin}/index.bundle?platform=${platform}&dev=true&minify=false`
+    const deadline = Date.now() + 10 * 60_000
+    let bundle
+    while (!bundle) {
+      assertRunning()
+      if (Date.now() > deadline)
+        throw new Error(`dev server ${platform} bundle timed out`)
+      const response = await fetch(url).catch(() => null)
+      if (response?.ok) bundle = Buffer.from(await response.arrayBuffer())
+      else await new Promise((resolve) => setTimeout(resolve, 2000))
+    }
+    const assets = new Map()
+    for (const [registration] of bundle
+      .toString('utf8')
+      .matchAll(/(?<=registerAsset\()\{[^{}]*"__packager_asset": true[^{}]*\}/g)) {
+      const asset = JSON.parse(registration)
+      const directory = packagedAssetDirectory(asset.httpServerLocation)
+      if (asset.files) {
+        for (const file of asset.files) {
+          const path = `${directory}/${basename(file)}`
+          if (!assets.has(path)) assets.set(path, readFileSync(file))
+        }
+        continue
+      }
+      // without local files, each scale downloads at the url react native's
+      // AssetSourceResolver builds for it
+      for (const scale of asset.scales) {
+        const file = `${asset.name}${scale === 1 ? '' : `@${scale}x`}.${asset.type}`
+        const path = `${directory}/${file}`
+        if (assets.has(path)) continue
+        const response = await fetch(
+          `${origin}${asset.httpServerLocation}/${file}?platform=${platform}&hash=${asset.hash}`,
+        )
+        if (!response.ok)
+          throw new Error(`dev server asset ${path} failed: ${response.status}`)
+        assets.set(path, Buffer.from(await response.arrayBuffer()))
+      }
+    }
+    snapshots.push({
+      platform,
+      bundle,
+      assets: [...assets].map(([path, bytes]) => ({ path, bytes })),
+      ...(platform === 'ios'
+        ? {
+            expoSwift: await (
+              await import('./expo-swift-bundle')
+            ).buildExpoSwiftBundle(projectRoot),
+          }
+        : {
+            expoKotlin: await (
+              await import('./expo-kotlin-bundle')
+            ).buildExpoKotlinBundle(projectRoot),
+          }),
+    })
+  }
+  return { platforms: snapshots }
+}
+
+// a One app's bundles, from a private dev server
 export async function snapshotOneDevBundle(projectRoot, env = {}) {
   const { spawn } = await import('node:child_process')
   const { readFileSync } = await import('node:fs')
   const { createServer } = await import('node:net')
-  const { basename, dirname, join } = await import('node:path')
+  const { dirname, join } = await import('node:path')
   const { createRequire } = await import('node:module')
   const onePackage = createRequire(join(projectRoot, 'package.json')).resolve(
     'one/package.json',
@@ -217,34 +352,12 @@ export async function snapshotOneDevBundle(projectRoot, env = {}) {
     detached: true,
   })
   try {
-    const url = `http://127.0.0.1:${port}/index.bundle?platform=ios&dev=true&minify=false`
-    const deadline = Date.now() + 10 * 60_000
-    let bundle
-    while (!bundle) {
-      if (child.exitCode !== null)
-        throw new Error(`one dev exited with ${child.exitCode}`)
-      if (Date.now() > deadline) throw new Error('one dev bundle timed out')
-      const response = await fetch(url).catch(() => null)
-      if (response?.ok) bundle = Buffer.from(await response.arrayBuffer())
-      else await new Promise((resolve) => setTimeout(resolve, 2000))
-    }
-    const assets = new Map()
-    for (const [registration] of bundle
-      .toString('utf8')
-      .matchAll(/(?<=registerAsset\()\{[^{}]*"__packager_asset": true[^{}]*\}/g)) {
-      const asset = JSON.parse(registration)
-      for (const file of asset.files) {
-        const path = `${asset.httpServerLocation.replace(/^\/+/, '')}/${basename(file)}`
-        if (!assets.has(path)) assets.set(path, readFileSync(file))
-      }
-    }
-    const { buildExpoSwiftBundle } = await import('./expo-swift-bundle')
-    const expoSwift = await buildExpoSwiftBundle(projectRoot)
-    return {
-      bundle,
-      assets: [...assets].map(([path, bytes]) => ({ path, bytes })),
-      expoSwift,
-    }
+    return await snapshotDevServerBundles(`http://127.0.0.1:${port}`, projectRoot, {
+      assertRunning: () => {
+        if (child.exitCode !== null)
+          throw new Error(`one dev exited with ${child.exitCode}`)
+      },
+    })
   } finally {
     await terminateProcessGroup(child)
   }

package/src/bundleGlobalFooter.ts

@@ -0,0 +1,38 @@
+// one `globalThis.<name>=<json>;` line a release publisher appends to a bundle,
+// which boot analysis reads before evaluating it. it sits before the module
+// path identity footer, which must stay the bundle's last line.
+
+export function readBundleGlobalFooter(source: string, name: string): unknown {
+  const prefix = `globalThis.${name}=`
+  const start = source.lastIndexOf(`\n${prefix}`)
+  if (start < 0) return null
+  const end = source.indexOf('\n', start + 1)
+  const line = source.slice(start + 1, end < 0 ? undefined : end)
+  if (!line.endsWith(';')) throw new Error(`${name} footer is truncated`)
+  const value: unknown = JSON.parse(line.slice(prefix.length, -1))
+  if (value === null) throw new Error(`${name} footer has no metadata`)
+  return value
+}
+
+export function insertBundleGlobalFooter(
+  source: string,
+  name: string,
+  value: unknown,
+): string {
+  const prefix = `globalThis.${name}=`
+  const start = source.lastIndexOf(`\n${prefix}`)
+  if (start >= 0) {
+    readBundleGlobalFooter(source, name)
+    const end = source.indexOf('\n', start + 1)
+    source = source.slice(0, start) + (end < 0 ? '' : source.slice(end))
+  }
+  const json = JSON.stringify(value)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/<\//g, '<\\/')
+  const footer = `\n${prefix}${json};`
+  const identity = source.lastIndexOf('\nglobalThis.__sootsimModulePaths=')
+  return identity < 0
+    ? source + footer
+    : source.slice(0, identity) + footer + source.slice(identity)
+}

package/src/capture-contract.ts

@@ -155,6 +155,8 @@ export interface RnxCaptureRegionRequest {
   /** host node whose own subtree is rendered into this transparent atlas region */
   nodeId: number
   frame: RnxCaptureRect
+  /** the region holds the node's own layer only; its children replay over it */
+  ownPaint?: true
 }
 
 export interface RnxRasterRegionTree {
@@ -186,22 +188,62 @@ function isLiveRasterSource(node: RnxRasterRegionTree['nodes'][number]): boolean
   )
 }
 
-export function selectRnxRasterNodeIds(tree: RnxRasterRegionTree): Set<number> {
+// the frame a raster layer captures, before paint outsets. a live source
+// (video, a gpu scene) is cut to its visible bounds: opaque content in front
+// of it replays semantically over the rest. one hidden entirely keeps its
+// layout frame. the budget and the region both read this, so a layer costs
+// the atlas exactly what it was budgeted.
+function rasterLayerFrame(node: RnxRasterRegionTree['nodes'][number]): RnxCaptureRect {
+  const visible = node.visibleFrame
+  if (isLiveRasterSource(node) && visible && visible.width > 0 && visible.height > 0) {
+    return { x: visible.x, y: visible.y, width: visible.width, height: visible.height }
+  }
+  return (
+    node.frame ?? {
+      x: node.absolutePosition.x,
+      y: node.absolutePosition.y,
+      width: node.layout.width,
+      height: node.layout.height,
+    }
+  )
+}
+
+// a live source the app renders itself on the gpu (an expo-gl or webgpu view:
+// a game, a 3d scene). its pixels are whatever the app draws next, so design
+// shows a placeholder there instead of photographing a frame.
+export function isGpuSceneSource(node: RnxRasterRegionTree['nodes'][number]): boolean {
+  if (!isLiveRasterSource(node)) return false
+  const source = node.props?.source
+  const uri = source && typeof source === 'object' ? Reflect.get(source, 'uri') : null
+  return (
+    typeof uri === 'string' &&
+    (uri.startsWith('live:expo-gl-') || uri.startsWith('live:wgpu-'))
+  )
+}
+
+// `nodeIds` is every node the atlas carries. a node in `ownPaint` carries only
+// its own layer: glass larger than a layer may hold (a sheet's material) is
+// captured without its children, which stay semantic and paint over it, and
+// the glass controls inside it keep their own regions.
+export type RnxRasterSelection = { nodeIds: Set<number>; ownPaint: Set<number> }
+
+export function selectRnxRasterNodeIds(tree: RnxRasterRegionTree): RnxRasterSelection {
   const nodesById = new Map(tree.nodes.map((node) => [node.nodeId, node]))
   const maxLayerArea = tree.width * tree.height * 0.25
-  // a layer over the per-layer cap never enters the atlas, so it cannot carry
-  // its descendants: a sheet's glass is too large, and the glass controls
-  // inside it still need their own regions.
-  const eligible = new Map<number, { nodeId: number; area: number; liveVideo: boolean }>()
+  const eligible = new Map<
+    number,
+    { nodeId: number; area: number; liveVideo: boolean; ownPaint: boolean }
+  >()
   for (const node of tree.nodes) {
     const liveVideo = isLiveRasterSource(node)
-    const visibleFrame =
-      liveVideo &&
-      node.visibleFrame &&
-      (node.visibleFrame.width <= 0 || node.visibleFrame.height <= 0)
-        ? node.frame
-        : (node.visibleFrame ?? node.frame)
+    const visibleFrame = liveVideo
+      ? rasterLayerFrame(node)
+      : (node.visibleFrame ?? node.frame)
     if (!visibleFrame || visibleFrame.width <= 0 || visibleFrame.height <= 0) continue
+    const glass =
+      node.style._liquidGlass !== undefined ||
+      node.style._liquidGlassEdge !== undefined ||
+      node.style._liquidGlassMaterialTint !== undefined
     const unsupported =
       node.type === 'masked-view' ||
       liveVideo ||
@@ -211,40 +253,58 @@ export function selectRnxRasterNodeIds(tree: RnxRasterRegionTree): Set<number> {
           /\uFE0F|\u200D|\u20E3|\p{Emoji_Modifier}|\p{Regional_Indicator}/u.test(
             node.text,
           ))) ||
-      node.style._liquidGlass !== undefined ||
-      node.style._liquidGlassEdge !== undefined ||
-      node.style._liquidGlassMaterialTint !== undefined
-    const area = visibleFrame.width * visibleFrame.height
-    if (unsupported && (liveVideo || area <= maxLayerArea)) {
-      eligible.set(node.nodeId, { nodeId: node.nodeId, area, liveVideo })
+      glass
+    if (!unsupported) continue
+    const captured = rasterLayerFrame(node)
+    const area = captured.width * captured.height
+    if (liveVideo || area <= maxLayerArea) {
+      eligible.set(node.nodeId, { nodeId: node.nodeId, area, liveVideo, ownPaint: false })
+    } else if (glass) {
+      eligible.set(node.nodeId, { nodeId: node.nodeId, area, liveVideo, ownPaint: true })
     }
   }
+  // a whole-subtree layer absorbs the layers inside it; an own-paint layer
+  // leaves them their own regions.
   for (const nodeId of [...eligible.keys()]) {
     let parentNodeId = nodesById.get(nodeId)?.parentNodeId ?? null
     while (parentNodeId !== null) {
-      if (eligible.has(parentNodeId)) {
+      const parent = eligible.get(parentNodeId)
+      if (parent && !parent.ownPaint) {
         eligible.delete(nodeId)
         break
       }
       parentNodeId = nodesById.get(parentNodeId)?.parentNodeId ?? null
     }
   }
+  // live video and own-paint glass (a whole sheet's material) claim the atlas
+  // first, up to a screen between them; the other layers follow smallest
+  // first, up to half a screen of their own. the whole atlas stays within a
+  // screen and a quarter, which the packer's pixel budget holds at 3x.
   const candidates = [...eligible.values()].sort(
     (left, right) =>
       Number(right.liveVideo) - Number(left.liveVideo) ||
+      Number(right.ownPaint) - Number(left.ownPaint) ||
       left.area - right.area ||
       left.nodeId - right.nodeId,
   )
   const screenArea = tree.width * tree.height
-  const selected = new Set<number>()
+  const selection: RnxRasterSelection = { nodeIds: new Set(), ownPaint: new Set() }
   let atlasArea = 0
+  let layerArea = 0
   for (const candidate of candidates) {
-    const maxAtlasArea = screenArea * (candidate.liveVideo ? 1 : 0.5)
-    if (atlasArea + candidate.area > maxAtlasArea) continue
-    selected.add(candidate.nodeId)
+    const leading = candidate.liveVideo || candidate.ownPaint
+    if (
+      atlasArea + candidate.area > screenArea * (leading ? 1 : 1.25) ||
+      (!leading && layerArea + candidate.area > screenArea * 0.5)
+    ) {
+      continue
+    }
+    selection.nodeIds.add(candidate.nodeId)
+    if (candidate.ownPaint) selection.ownPaint.add(candidate.nodeId)
     atlasArea += candidate.area
+    if (!leading) layerArea += candidate.area
   }
-  return selected
+  return selection
 }
 
 export function rnxRasterFrames(
@@ -254,12 +314,7 @@ export function rnxRasterFrames(
   const frames = new Map<number, RnxCaptureRect>()
   for (const node of tree.nodes) {
     if (!nodeIds.has(node.nodeId)) continue
-    const frame = node.frame ?? {
-      x: node.absolutePosition.x,
-      y: node.absolutePosition.y,
-      width: node.layout.width,
-      height: node.layout.height,
-    }
+    const frame = rasterLayerFrame(node)
     // a region is what the node paints, and nothing else: a producer that crops
     // a composited screenshot copies every pixel inside it, so any margin past
     // the paint carries neighbours (a header title, a hairline, a list row)
@@ -371,11 +426,27 @@ export function rnxCaptureRasterRegions(
       visibleFrame: node.layout.visibleFrame,
     })),
   }
-  const nodeIds = selectRnxRasterNodeIds(tree)
-  const frames = rnxRasterFrames(tree, nodeIds)
-  return [...nodeIds].flatMap((nodeId) => {
+  const selection = selectRnxRasterNodeIds(tree)
+  return rnxRasterRegionRequests(tree, selection)
+}
+
+// the region requests a producer packs for a selection
+export function rnxRasterRegionRequests(
+  tree: RnxRasterRegionTree,
+  selection: RnxRasterSelection,
+): RnxCaptureRegionRequest[] {
+  const frames = rnxRasterFrames(tree, selection.nodeIds)
+  return [...selection.nodeIds].flatMap((nodeId) => {
     const frame = frames.get(nodeId)
-    return frame ? [{ key: String(nodeId), nodeId, frame }] : []
+    if (!frame) return []
+    return [
+      {
+        key: String(nodeId),
+        nodeId,
+        frame,
+        ...(selection.ownPaint.has(nodeId) ? { ownPaint: true as const } : {}),
+      },
+    ]
   })
 }
 
@@ -445,6 +516,7 @@ export function packRnxCaptureRegions(
     return {
       key: region.key,
       nodeId: region.nodeId,
+      ...(region.ownPaint ? { ownPaint: true as const } : {}),
       frame: {
         x: left / pixelRatio,
         y: top / pixelRatio,
@@ -514,6 +586,7 @@ export function packRnxCaptureRegions(
     atlasRegions: best.regions.map((region) => ({
       key: region.key,
       nodeId: region.nodeId,
+      ...(region.ownPaint ? { ownPaint: true as const } : {}),
       frame: region.frame,
       // a region flush with the far edge is anchored to the logical edge so
       // its source never runs past the atlas by a rounding hair
@@ -784,6 +857,7 @@ export function isRnxCaptureRegionAtlas(value: unknown): value is RnxCaptureRegi
       keys.has(region.key) ||
       !captureInteger(region.nodeId) ||
       region.nodeId <= 0 ||
+      (region.ownPaint !== undefined && region.ownPaint !== true) ||
       !captureRect(region.frame) ||
       region.frame.width <= 0 ||
       region.frame.height <= 0 ||

package/src/cloud-contract.ts

@@ -1,6 +1,10 @@
 import type { BridgeCommandType } from './bridge-contract.ts'
 
-export const RNX_CLOUD_MAX_ARTIFACT_BYTES = 20 * 1024 * 1024
+// largest guest artifact a nano isolate measurably boots, settles, screenshots,
+// and survives repeated invocations within Cloudflare Dynamic Worker platform
+// limits (67,108,864 bytes total Dynamic Worker size minus 26,347,088 bytes engine
+// harness overhead).
+export const RNX_CLOUD_MAX_ARTIFACT_BYTES = 40_761_776
 export const RNX_CLOUD_DESIGN_MAX_STORAGE_ENTRIES = 256
 export const RNX_CLOUD_DESIGN_MAX_STORAGE_BYTES = 1024 * 1024
 export const RNX_CLOUD_TEST_FILES_MAX_COUNT = 256