Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
// Pure helpers shared by the scenario: FNV-1a 64, the bench timecode reader,
// the WAV writer and the client wall clock. No SDK imports, so they can be
// unit-tested without the native library (`node --test pixels.test.ts`).
/** FNV-1a 64 over `bytes`, as 16 lowercase hex digits. */
export function fnv1a64(bytes: Uint8Array): string {
// 64-bit state as two u32 halves; prime = 2^40 + 0x1b3.
let hi = 0xcbf29ce4
let lo = 0x84222325
for (let i = 0; i < bytes.length; i++) {
lo = (lo ^ bytes[i]) >>> 0
const loMul = lo * 0x1b3 // < 2^41, exact in a double
const carry = Math.floor(loMul / 4294967296)
const hiMul = hi * 0x1b3 + carry + ((lo << 8) >>> 0)
lo = loMul >>> 0
hi = hiMul % 4294967296
}
return hi.toString(16).padStart(8, "0") + lo.toString(16).padStart(8, "0")
}
/** Client wall clock in unix nanoseconds (sub-microsecond resolution). */
export function unixNs(): bigint {
const ms = performance.timeOrigin + performance.now()
return BigInt(Math.floor(ms * 1000)) * 1000n
}
export type PixelLayout = { r: number; g: number; b: number } // byte offsets in a 4-byte pixel
export const BGRA: PixelLayout = { r: 2, g: 1, b: 0 }
export const RGBA: PixelLayout = { r: 0, g: 1, b: 2 }
/** The pixel at (x, y) of a packed 4-byte-per-pixel image, as [r, g, b]. */
export function pixelAt(
data: Uint8Array,
width: number,
stride: number,
x: number,
y: number,
layout: PixelLayout,
): [number, number, number] {
const px = Math.max(0, Math.min(width - 1, Math.round(x)))
const i = Math.round(y) * stride + px * 4
return [data[i + layout.r], data[i + layout.g], data[i + layout.b]]
}
const CELL = 16
const CELLS = 48
/**
* Reads the bench timecode strip (SCENARIO.md "Bench timecode") at frame
* pixel (0, 0) with `scale` = frame width / window content width. Returns
* the full unix-ms value rebuilt around `clientUnixMs`, or null when either
* sync pattern or the checksum does not match.
*/
export function readTimecode(
data: Uint8Array,
width: number,
height: number,
stride: number,
scale: number,
layout: PixelLayout,
clientUnixMs: number,
): number | null {
if (width < Math.ceil(CELL * CELLS * scale) || height < Math.ceil(10 * scale)) return null
const bits: number[] = []
for (let c = 0; c < CELLS; c++) {
let sum = 0
for (let dy = 6; dy <= 9; dy++) {
const y = Math.min(height - 1, Math.round(dy * scale))
for (let dx = 6; dx <= 9; dx++) {
const x = Math.min(width - 1, Math.round((CELL * c + dx) * scale))
const i = y * stride + x * 4
sum += data[i + layout.r] + data[i + layout.g] + data[i + layout.b]
}
}
bits.push(sum / 48 > 128 ? 1 : 0)
}
const syncA = [1, 0, 1, 0]
const syncB = [0, 1, 0, 1]
for (let i = 0; i < 4; i++) {
if (bits[i] !== syncA[i] || bits[44 + i] !== syncB[i]) return null
}
let value = 0
for (let i = 4; i < 36; i++) value = value * 2 + bits[i]
let checksum = 0
for (let i = 36; i < 44; i++) checksum = checksum * 2 + bits[i]
const xor = ((value >>> 24) ^ (value >>> 16) ^ (value >>> 8) ^ value) & 0xff
if (xor !== checksum) return null
const window = 4294967296
const base = clientUnixMs - (clientUnixMs % window)
let best = base + value
for (const candidate of [base + value - window, base + value + window]) {
if (Math.abs(candidate - clientUnixMs) < Math.abs(best - clientUnixMs)) best = candidate
}
return best
}
/** A 16-bit PCM WAV file (little endian) from interleaved samples. */
export function wavBytes(chunks: Int16Array[], sampleRate: number, channels: number): Uint8Array {
const total = chunks.reduce((n, c) => n + c.length, 0)
const dataBytes = total * 2
const out = new Uint8Array(44 + dataBytes)
const v = new DataView(out.buffer)
const ascii = (at: number, s: string) => {
for (let i = 0; i < s.length; i++) out[at + i] = s.charCodeAt(i)
}
ascii(0, "RIFF")
v.setUint32(4, 36 + dataBytes, true)
ascii(8, "WAVE")
ascii(12, "fmt ")
v.setUint32(16, 16, true)
v.setUint16(20, 1, true)
v.setUint16(22, channels, true)
v.setUint32(24, sampleRate, true)
v.setUint32(28, sampleRate * channels * 2, true)
v.setUint16(32, channels * 2, true)
v.setUint16(34, 16, true)
ascii(36, "data")
v.setUint32(40, dataBytes, true)
let at = 44
for (const chunk of chunks) {
for (let i = 0; i < chunk.length; i++, at += 2) v.setInt16(at, chunk[i], true)
}
return out
}