Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import type { BrowserScreencastFrameMetadata } from '../transport/browser-screencast-protocol'
export type BrowserTouchLayout = {
width: number
height: number
}
export type BrowserPoint = {
x: number
y: number
}
export type BrowserFrameGeometry = {
sourceWidth: number
sourceHeight: number
viewportWidth: number
viewportHeight: number
renderedWidth: number
renderedHeight: number
offsetX: number
offsetY: number
scale: number
// Convert frame device pixels to page CSS pixels: no-meta mobile page scales Chromium’s 980px layout into phone viewport; web mode has scale 1.
pageScale: number
}
export type BrowserZoomState = {
scale: number
offsetX: number
offsetY: number
}
export function computeBrowserFrameGeometry(
layout: BrowserTouchLayout | null,
metadata: BrowserScreencastFrameMetadata | null
): BrowserFrameGeometry | null {
if (!layout || layout.width <= 0 || layout.height <= 0) {
return null
}
const sourceWidth = getPositiveFiniteNumber(metadata?.deviceWidth) ?? layout.width
const sourceHeight = getPositiveFiniteNumber(metadata?.deviceHeight) ?? layout.height
const scale = Math.min(layout.width / sourceWidth, layout.height / sourceHeight)
if (!Number.isFinite(scale) || scale <= 0) {
return null
}
const renderedWidth = sourceWidth * scale
const renderedHeight = sourceHeight * scale
return {
pageScale: getPositiveFiniteNumber(metadata?.pageScaleFactor) ?? 1,
sourceWidth,
sourceHeight,
viewportWidth: layout.width,
viewportHeight: layout.height,
renderedWidth,
renderedHeight,
offsetX: (layout.width - renderedWidth) / 2,
offsetY: (layout.height - renderedHeight) / 2,
scale
}
}
export function mapScreenToBrowserPoint(
x: number,
y: number,
layout: BrowserTouchLayout | null,
metadata: BrowserScreencastFrameMetadata | null,
zoom: BrowserZoomState
): BrowserPoint | null {
const geometry = computeBrowserFrameGeometry(layout, metadata)
if (!geometry || zoom.scale <= 0) {
return null
}
const frameCenterX = geometry.offsetX + geometry.renderedWidth / 2 + zoom.offsetX
const frameCenterY = geometry.offsetY + geometry.renderedHeight / 2 + zoom.offsetY
const localX = (x - frameCenterX) / zoom.scale + geometry.renderedWidth / 2
const localY = (y - frameCenterY) / zoom.scale + geometry.renderedHeight / 2
if (
localX < 0 ||
localY < 0 ||
localX > geometry.renderedWidth ||
localY > geometry.renderedHeight
) {
return null
}
// CDP input uses viewport CSS coordinates; adding scrollOffset aims past target by a page scroll.
return {
x: clamp(
Math.round(((localX / geometry.renderedWidth) * geometry.sourceWidth) / geometry.pageScale),
0,
geometry.sourceWidth / geometry.pageScale
),
y: clamp(
Math.round(((localY / geometry.renderedHeight) * geometry.sourceHeight) / geometry.pageScale),
0,
geometry.sourceHeight / geometry.pageScale
)
}
}
/** A scroll the page should receive, in its own CSS pixels, the way a wheel reports one. */
export type BrowserWheelDelta = { dx: number; dy: number }
// Compose frame-to-pane fit, pinch zoom and page scale for every screen delta; omitting last factor produced only 41% scroll on no-meta page. Return null if unreadable.
export function browserScreenToPageCssScale(
geometry: BrowserFrameGeometry | null,
zoomScale: number
): number | null {
const scale = geometry === null ? zoomScale : geometry.scale * zoomScale * geometry.pageScale
return Number.isFinite(scale) && scale > 0 ? scale : null
}
/** A screen-space gesture delta as the page's own CSS pixels, inverted the way a wheel reports it. */
export function browserWheelDeltaFromScreen(
screenDx: number,
screenDy: number,
geometry: BrowserFrameGeometry | null,
zoomScale: number
): BrowserWheelDelta {
const scale = browserScreenToPageCssScale(geometry, zoomScale) ?? 1
return { dx: roundedWheelDelta(-screenDx / scale), dy: roundedWheelDelta(-screenDy / scale) }
}
/** `Math.round` answers -0 for an axis that moved nothing; the wheel carries a plain zero. */
function roundedWheelDelta(value: number): number {
const rounded = Math.round(value)
return rounded === 0 ? 0 : rounded
}
export function computeBrowserTouchClickRadiusCss(
layout: BrowserTouchLayout | null,
metadata: BrowserScreencastFrameMetadata | null,
zoom: BrowserZoomState,
touchRadiusDip: number
): number {
const geometry = computeBrowserFrameGeometry(layout, metadata)
const scale = browserScreenToPageCssScale(geometry, zoom.scale)
if (scale === null) {
return 10
}
// Convert finger-sized screen radius back to CSS pixels so pixel-exact CDP taps can hit tiny links.
return clamp(Math.round(touchRadiusDip / scale), 6, 48)
}
export function clampBrowserZoomState(
next: BrowserZoomState,
geometry: BrowserFrameGeometry,
minZoom: number,
maxZoom: number
): BrowserZoomState {
const scale = clamp(next.scale, minZoom, maxZoom)
if (scale <= minZoom + 0.01) {
return { scale: minZoom, offsetX: 0, offsetY: 0 }
}
const maxOffsetX = Math.max(0, (geometry.renderedWidth * scale - geometry.viewportWidth) / 2)
const maxOffsetY = Math.max(0, (geometry.renderedHeight * scale - geometry.viewportHeight) / 2)
return {
scale,
offsetX: clamp(next.offsetX, -maxOffsetX, maxOffsetX),
offsetY: clamp(next.offsetY, -maxOffsetY, maxOffsetY)
}
}
export function readLocalTouchPoint(touch: unknown): BrowserPoint | null {
if (!touch || typeof touch !== 'object') {
return null
}
const eventTouch = touch as {
locationX?: unknown
locationY?: unknown
}
if (
typeof eventTouch.locationX !== 'number' ||
!Number.isFinite(eventTouch.locationX) ||
typeof eventTouch.locationY !== 'number' ||
!Number.isFinite(eventTouch.locationY)
) {
return null
}
return { x: eventTouch.locationX, y: eventTouch.locationY }
}
function getPositiveFiniteNumber(value: unknown): number | null {
return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null
}
function clamp(value: number, min: number, max: number): number {
return Math.max(min, Math.min(max, value))
}