rnxsim 0.1.543 → 0.1.545

package/src/capture-contract.ts

@@ -318,6 +318,146 @@ export function rnxCaptureRasterRegions(
   })
 }
 
+/** a region request snapped to the surface pixel grid and placed in the atlas */
+export interface RnxPackedCaptureRegion extends RnxCaptureRegionRequest {
+  /** top-left of the region on the app surface, in pixels */
+  sourceX: number
+  sourceY: number
+  pixelWidth: number
+  pixelHeight: number
+  /** top-left of the region inside the atlas, in pixels */
+  atlasX: number
+  atlasY: number
+}
+
+export interface RnxPackedCaptureAtlas {
+  /** logical atlas dimensions; pixel dimensions are these times the pixel ratio */
+  width: number
+  height: number
+  pixelWidth: number
+  pixelHeight: number
+  regions: RnxPackedCaptureRegion[]
+  /** the wire regions a producer publishes beside the encoded atlas */
+  atlasRegions: RnxCaptureAtlasRegion[]
+}
+
+// the bounded selective-layer atlas every producer ships: regions snapped to
+// whole surface pixels, shelf-packed into the smallest of a few candidate
+// widths, and mapped back to logical atlas coordinates. one packer for the
+// headless renderer (which draws isolated subtrees into the slots) and the
+// browser producer (which crops them out of a screen-sized screenshot), so a
+// consumer never learns which one made the artifact from the layout.
+export function packRnxCaptureRegions(
+  regions: readonly RnxCaptureRegionRequest[],
+  pixelRatio: number,
+  surface: { pixelWidth: number; pixelHeight: number },
+): RnxPackedCaptureAtlas {
+  const physical = regions.map((region) => {
+    const left = Math.floor(region.frame.x * pixelRatio)
+    const top = Math.floor(region.frame.y * pixelRatio)
+    const right = Math.ceil((region.frame.x + region.frame.width) * pixelRatio)
+    const bottom = Math.ceil((region.frame.y + region.frame.height) * pixelRatio)
+    if (
+      left < 0 ||
+      top < 0 ||
+      right > surface.pixelWidth ||
+      bottom > surface.pixelHeight ||
+      right <= left ||
+      bottom <= top
+    ) {
+      throw new Error(`capture region ${region.key} is outside the app surface`)
+    }
+    return {
+      key: region.key,
+      nodeId: region.nodeId,
+      frame: {
+        x: left / pixelRatio,
+        y: top / pixelRatio,
+        width: (right - left) / pixelRatio,
+        height: (bottom - top) / pixelRatio,
+      },
+      sourceX: left,
+      sourceY: top,
+      pixelWidth: right - left,
+      pixelHeight: bottom - top,
+    }
+  })
+  const largestWidth = Math.max(...physical.map((region) => region.pixelWidth))
+  const totalArea = physical.reduce(
+    (area, region) => area + region.pixelWidth * region.pixelHeight,
+    0,
+  )
+  if (totalArea > 4_194_304) {
+    throw new Error('capture region pixels exceed the atlas budget')
+  }
+  const candidates = [
+    largestWidth,
+    Math.max(largestWidth, Math.ceil(Math.sqrt(totalArea))),
+    Math.max(largestWidth, surface.pixelWidth),
+    4_096,
+  ]
+  const ordered = [...physical].sort(
+    (left, right) =>
+      right.pixelHeight - left.pixelHeight ||
+      right.pixelWidth - left.pixelWidth ||
+      left.key.localeCompare(right.key),
+  )
+  let best: { width: number; height: number; regions: RnxPackedCaptureRegion[] } | null =
+    null
+  for (const candidate of [...new Set(candidates)]) {
+    if (candidate > 4_096) continue
+    let x = 0
+    let y = 0
+    let rowHeight = 0
+    let usedWidth = 0
+    const packed: RnxPackedCaptureRegion[] = []
+    for (const region of ordered) {
+      if (x > 0 && x + region.pixelWidth > candidate) {
+        y += rowHeight
+        x = 0
+        rowHeight = 0
+      }
+      packed.push({ ...region, atlasX: x, atlasY: y })
+      x += region.pixelWidth
+      rowHeight = Math.max(rowHeight, region.pixelHeight)
+      usedWidth = Math.max(usedWidth, x)
+    }
+    const height = y + rowHeight
+    if (height > 4_096 || usedWidth * height > 4_194_304) continue
+    const result = { width: usedWidth, height, regions: packed }
+    if (!best || result.width * result.height < best.width * best.height) best = result
+  }
+  if (!best) throw new Error('capture regions cannot fit in one bounded atlas')
+  const width = best.width / pixelRatio
+  const height = best.height / pixelRatio
+  return {
+    width,
+    height,
+    pixelWidth: best.width,
+    pixelHeight: best.height,
+    regions: best.regions,
+    atlasRegions: best.regions.map((region) => ({
+      key: region.key,
+      nodeId: region.nodeId,
+      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
+      source: {
+        x:
+          region.atlasX + region.pixelWidth === best.width
+            ? width - region.frame.width
+            : region.atlasX / pixelRatio,
+        y:
+          region.atlasY + region.pixelHeight === best.height
+            ? height - region.frame.height
+            : region.atlasY / pixelRatio,
+        width: region.frame.width,
+        height: region.frame.height,
+      },
+    })),
+  }
+}
+
 export interface RnxCaptureAtlasRegion extends RnxCaptureRegionRequest {
   /** source rectangle inside the packed atlas, in logical atlas coordinates */
   source: RnxCaptureRect
@@ -325,7 +465,7 @@ export interface RnxCaptureAtlasRegion extends RnxCaptureRegionRequest {
 
 export interface RnxCaptureRegionAtlas {
   kind: 'png-atlas'
-  producer: 'headless-cpu-app-surface'
+  producer: 'headless-cpu-app-surface' | 'browser-compositor-app-surface'
   dataUri: string
   /** logical atlas dimensions; the encoded PNG uses pixelWidth × pixelHeight */
   width: number
@@ -533,7 +673,8 @@ export function isRnxCaptureRegionAtlas(value: unknown): value is RnxCaptureRegi
   if (
     !captureRecord(value) ||
     value.kind !== 'png-atlas' ||
-    value.producer !== 'headless-cpu-app-surface' ||
+    (value.producer !== 'headless-cpu-app-surface' &&
+      value.producer !== 'browser-compositor-app-surface') ||
     typeof value.dataUri !== 'string' ||
     !value.dataUri.startsWith('data:image/png;base64,') ||
     !captureNumber(value.width) ||

package/src/index.ts

@@ -39,6 +39,7 @@ export {
   isRnxCaptureRegionAtlas,
   isRnxScreenCapture,
   rnxCaptureRasterRegions,
+  packRnxCaptureRegions,
   rnxRasterFrames,
   RNX_SCREEN_CAPTURE_VERSION,
   selectRnxRasterNodeIds,
@@ -54,6 +55,8 @@ export {
   type RnxCaptureSource,
   type RnxCaptureStyleTokenBinding,
   type RnxCaptureTextLine,
+  type RnxPackedCaptureAtlas,
+  type RnxPackedCaptureRegion,
   type RnxCaptureTextSegment,
   type RnxCaptureTree,
   type RnxCaptureVisualEvidence,