whale-code 6.4.0 → 6.5.0

package/dist/node/portal/ui.js

@@ -0,0 +1,148 @@
+/**
+ * Portal UI — terminal progress bars, status display, and interactive menu.
+ */
+// ============================================================================
+// NODE LIST
+// ============================================================================
+export function printNodeList(nodes, showOffline = false) {
+    if (nodes.length === 0) {
+        console.log("No nodes online in your store.");
+        console.log("  Run `whale node start` on a machine to bring it online.");
+        return;
+    }
+    const online = nodes.filter(n => n.status === "online");
+    const offline = nodes.filter(n => n.status === "offline");
+    console.log(`\nOnline Nodes (${online.length}):\n`);
+    console.log("  NAME                 HOSTNAME              PLATFORM    STATUS");
+    console.log("  " + "─".repeat(70));
+    for (const n of online) {
+        const name = n.name.padEnd(20).slice(0, 20);
+        const host = n.hostname.padEnd(20).slice(0, 20);
+        const plat = n.platform.padEnd(10).slice(0, 10);
+        console.log(`  ${name} ${host}  ${plat}  online`);
+    }
+    if (showOffline && offline.length > 0) {
+        console.log(`\nOffline Nodes (${offline.length}):\n`);
+        for (const n of offline) {
+            const name = n.name.padEnd(20).slice(0, 20);
+            const host = n.hostname.padEnd(20).slice(0, 20);
+            const plat = n.platform.padEnd(10).slice(0, 10);
+            console.log(`  ${name} ${host}  ${plat}  offline`);
+        }
+    }
+    console.log();
+}
+// ============================================================================
+// TRANSFER PROGRESS
+// ============================================================================
+let lastProgressLine = "";
+export function printProgress(progress) {
+    const bar = makeBar(progress.percent, 30);
+    const size = formatBytes(progress.bytesTransferred);
+    const total = progress.totalBytes > 0 ? formatBytes(progress.totalBytes) : "?";
+    const line = `  ${progress.name}: ${bar} ${progress.percent}% (${size}/${total})`;
+    if (line !== lastProgressLine) {
+        process.stderr.write(`\r${line}`);
+        lastProgressLine = line;
+    }
+    if (progress.percent >= 100) {
+        process.stderr.write("\n");
+        lastProgressLine = "";
+    }
+}
+function makeBar(percent, width) {
+    const filled = Math.round((percent / 100) * width);
+    return "[" + "█".repeat(filled) + "░".repeat(width - filled) + "]";
+}
+// ============================================================================
+// SESSION STATUS
+// ============================================================================
+export function printSessionStatus(sessions) {
+    if (sessions.length === 0) {
+        console.log("No active portal sessions.");
+        return;
+    }
+    console.log(`\nActive Sessions (${sessions.length}):\n`);
+    console.log("  SESSION                                TARGET               STREAMS  STATUS");
+    console.log("  " + "─".repeat(75));
+    for (const s of sessions) {
+        const sid = s.session_id.slice(0, 8);
+        const target = (s.target_hostname || s.target_node_id || "unknown").padEnd(20).slice(0, 20);
+        const streams = String(s.active_streams).padEnd(8);
+        const status = s.accepted ? "connected" : "pending";
+        console.log(`  ${sid}  ${target} ${streams} ${status}`);
+    }
+    console.log();
+}
+// ============================================================================
+// FORWARD STATUS
+// ============================================================================
+export function printForwardStatus(forwards) {
+    if (forwards.length === 0) {
+        console.log("No active port forwards.");
+        return;
+    }
+    console.log(`\nActive Forwards (${forwards.length}):\n`);
+    for (const f of forwards) {
+        console.log(`  localhost:${f.localPort} → remote:${f.remotePort} (${f.connections} connections)`);
+    }
+    console.log();
+}
+// ============================================================================
+// INTERACTIVE MENU
+// ============================================================================
+export async function showPortalMenu(nodeName) {
+    const { createInterface } = await import("node:readline");
+    console.log(`\nPortal to ${nodeName}\n`);
+    console.log("  1) Shell           Open remote terminal");
+    console.log("  2) Push file       Send file to remote node");
+    console.log("  3) Pull file       Get file from remote node");
+    console.log("  4) Port forward    Forward local port to remote");
+    console.log("  5) Screen share    View remote desktop");
+    console.log("  6) Clipboard       Sync clipboards");
+    console.log("  q) Quit\n");
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question("  Choose: ", (answer) => {
+            rl.close();
+            const choice = answer.trim().toLowerCase();
+            const map = {
+                "1": "shell", "2": "push", "3": "pull",
+                "4": "forward", "5": "screen", "6": "clipboard",
+                "q": "quit", "shell": "shell", "push": "push",
+                "pull": "pull", "forward": "forward", "screen": "screen",
+                "clipboard": "clipboard", "quit": "quit",
+            };
+            resolve(map[choice] || "unknown");
+        });
+    });
+}
+// ============================================================================
+// CONNECTION STATUS
+// ============================================================================
+export function printConnecting(nodeName) {
+    process.stderr.write(`Connecting to ${nodeName}...`);
+}
+export function printConnected(hostname) {
+    process.stderr.write(`\rConnected to ${hostname}          \n`);
+}
+export function printDisconnected(reason) {
+    console.log(`\nDisconnected${reason ? `: ${reason}` : ""}`);
+}
+export function printError(msg) {
+    console.error(`Error: ${msg}`);
+}
+// ============================================================================
+// HELPERS
+// ============================================================================
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    const val = bytes / Math.pow(1024, i);
+    return `${val.toFixed(i > 0 ? 1 : 0)} ${units[i]}`;
+}

package/dist/node/remote-desktop/compile-helper.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Compiles the Swift screen-helper on first use, caches at ~/.whaletools/bin/screen-helper.
+ * Recompiles only when source file changes (mtime comparison).
+ * No-op on non-macOS platforms.
+ */
+export declare function getHelperBinaryPath(): string;
+export declare function isHelperAvailable(): boolean;
+/**
+ * Compile the Swift screen-helper if needed.
+ * Returns the path to the compiled binary.
+ * Throws if compilation fails or not on macOS.
+ */
+export declare function compileHelper(): string;

package/dist/node/remote-desktop/compile-helper.js

@@ -0,0 +1,73 @@
+/**
+ * Compiles the Swift screen-helper on first use, caches at ~/.whaletools/bin/screen-helper.
+ * Recompiles only when source file changes (mtime comparison).
+ * No-op on non-macOS platforms.
+ */
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SOURCE_FILE = join(__dirname, "screen-helper.swift");
+const BIN_DIR = join(homedir(), ".whaletools", "bin");
+const BINARY_PATH = join(BIN_DIR, "screen-helper");
+export function getHelperBinaryPath() {
+    return BINARY_PATH;
+}
+export function isHelperAvailable() {
+    return process.platform === "darwin" && existsSync(BINARY_PATH);
+}
+/**
+ * Compile the Swift screen-helper if needed.
+ * Returns the path to the compiled binary.
+ * Throws if compilation fails or not on macOS.
+ */
+export function compileHelper() {
+    if (process.platform !== "darwin") {
+        throw new Error("Screen helper is only available on macOS");
+    }
+    // Ensure bin directory exists
+    if (!existsSync(BIN_DIR)) {
+        mkdirSync(BIN_DIR, { recursive: true });
+    }
+    // Check if recompilation is needed
+    if (existsSync(BINARY_PATH)) {
+        try {
+            const srcStat = statSync(SOURCE_FILE);
+            const binStat = statSync(BINARY_PATH);
+            if (binStat.mtimeMs >= srcStat.mtimeMs) {
+                return BINARY_PATH; // Binary is up to date
+            }
+        }
+        catch {
+            // If stat fails, recompile
+        }
+    }
+    // Find source file — check dist location first, then src
+    let sourcePath = SOURCE_FILE;
+    if (!existsSync(sourcePath)) {
+        // When running from dist/, the swift file might be in src/
+        const srcPath = sourcePath.replace("/dist/", "/src/");
+        if (existsSync(srcPath)) {
+            sourcePath = srcPath;
+        }
+        else {
+            throw new Error(`Swift source not found at ${sourcePath} or ${srcPath}`);
+        }
+    }
+    console.log("[remote-desktop] Compiling screen-helper...");
+    try {
+        execSync(`swiftc -O "${sourcePath}" -framework ScreenCaptureKit -framework VideoToolbox -framework CoreMedia -framework CoreVideo -framework Network -framework AppKit -o "${BINARY_PATH}"`, {
+            stdio: "pipe",
+            timeout: 60_000,
+            encoding: "utf-8",
+        });
+        console.log("[remote-desktop] screen-helper compiled successfully");
+        return BINARY_PATH;
+    }
+    catch (err) {
+        const stderr = err.stderr || err.message;
+        throw new Error(`Failed to compile screen-helper: ${stderr}`);
+    }
+}

package/dist/node/remote-desktop/index.d.ts

@@ -0,0 +1,67 @@
+/**
+ * ScreenCaptureService — EventEmitter-based screen capture for Mac whale-node.
+ *
+ * Spawns the Swift screen-helper for H.264 hardware-encoded screen capture.
+ * Emits frames as events for any number of consumers (Portal streams, etc.).
+ *
+ * The Swift helper handles:
+ *   - Direct LAN WebSocket + Bonjour (iPad connects directly)
+ *   - H.264 hardware encoding via VTCompressionSession
+ *   - Input injection via CGEvent
+ *
+ * This service handles:
+ *   - Helper lifecycle (compile, spawn, restart)
+ *   - Reading stdout frames for Node.js consumers (Portal relay, gateway)
+ *   - Forwarding input events to helper stdin
+ *   - Caching latest frame + config for new viewers
+ */
+import { EventEmitter } from "node:events";
+import { type InputEvent } from "./protocol.js";
+export interface ScreenCaptureConfig {
+    enabled: boolean;
+    max_fps: number;
+}
+export interface CaptureStatus {
+    capturing: boolean;
+    logicalWidth: number;
+    logicalHeight: number;
+    captureWidth: number;
+    captureHeight: number;
+    codec: string;
+    listeners: number;
+}
+export declare class ScreenCaptureService extends EventEmitter {
+    private config;
+    private helper;
+    latestFrame: Buffer | null;
+    latestConfig: Buffer | null;
+    private _logicalWidth;
+    private _logicalHeight;
+    private _captureWidth;
+    private _captureHeight;
+    private _capturing;
+    private stdoutBuffer;
+    constructor(config?: Partial<ScreenCaptureConfig>);
+    get logicalWidth(): number;
+    get logicalHeight(): number;
+    get captureWidth(): number;
+    get captureHeight(): number;
+    get capturing(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Forward input event to the Swift helper via stdin.
+     */
+    injectInput(event: InputEvent): void;
+    /**
+     * Forward a control message (request_keyframe, quality) to the Swift helper.
+     */
+    sendControlMessage(msg: {
+        type: string;
+        [key: string]: unknown;
+    }): void;
+    getStatus(): CaptureStatus;
+    private spawnHelper;
+    private processFrameBuffer;
+    private handleHelperStatus;
+}

package/dist/node/remote-desktop/index.js

@@ -0,0 +1,220 @@
+/**
+ * ScreenCaptureService — EventEmitter-based screen capture for Mac whale-node.
+ *
+ * Spawns the Swift screen-helper for H.264 hardware-encoded screen capture.
+ * Emits frames as events for any number of consumers (Portal streams, etc.).
+ *
+ * The Swift helper handles:
+ *   - Direct LAN WebSocket + Bonjour (iPad connects directly)
+ *   - H.264 hardware encoding via VTCompressionSession
+ *   - Input injection via CGEvent
+ *
+ * This service handles:
+ *   - Helper lifecycle (compile, spawn, restart)
+ *   - Reading stdout frames for Node.js consumers (Portal relay, gateway)
+ *   - Forwarding input events to helper stdin
+ *   - Caching latest frame + config for new viewers
+ */
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { createInterface } from "node:readline";
+import { compileHelper } from "./compile-helper.js";
+import { FrameType, parseFrameHeaderV4, isV4Frame, } from "./protocol.js";
+const DEFAULT_CONFIG = {
+    enabled: true,
+    max_fps: 60,
+};
+export class ScreenCaptureService extends EventEmitter {
+    config;
+    helper = null;
+    // Frame caching — latest of each type for new viewers
+    latestFrame = null;
+    latestConfig = null; // SPS/PPS for decoder init
+    // Display dimensions (from parsed frames)
+    _logicalWidth = 0;
+    _logicalHeight = 0;
+    _captureWidth = 0;
+    _captureHeight = 0;
+    _capturing = false;
+    // Stdout frame assembly
+    stdoutBuffer = Buffer.alloc(0);
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.setMaxListeners(50); // Multiple portal streams can listen
+    }
+    get logicalWidth() { return this._logicalWidth; }
+    get logicalHeight() { return this._logicalHeight; }
+    get captureWidth() { return this._captureWidth; }
+    get captureHeight() { return this._captureHeight; }
+    get capturing() { return this._capturing; }
+    async start() {
+        if (process.platform !== "darwin") {
+            console.log("[screen-capture] Not macOS, skipping");
+            return;
+        }
+        let helperPath;
+        try {
+            helperPath = compileHelper();
+        }
+        catch (err) {
+            console.error("[screen-capture] Failed to compile helper:", err.message);
+            return;
+        }
+        this.spawnHelper(helperPath);
+    }
+    async stop() {
+        if (this.helper) {
+            this.helper.kill("SIGTERM");
+            this.helper = null;
+        }
+        this._capturing = false;
+        this.latestFrame = null;
+        this.latestConfig = null;
+        this.emit("stopped");
+        console.log("[screen-capture] Stopped");
+    }
+    /**
+     * Forward input event to the Swift helper via stdin.
+     */
+    injectInput(event) {
+        if (this.helper?.stdin?.writable) {
+            this.helper.stdin.write(JSON.stringify(event) + "\n");
+        }
+    }
+    /**
+     * Forward a control message (request_keyframe, quality) to the Swift helper.
+     */
+    sendControlMessage(msg) {
+        if (this.helper?.stdin?.writable) {
+            this.helper.stdin.write(JSON.stringify(msg) + "\n");
+        }
+    }
+    getStatus() {
+        return {
+            capturing: this._capturing,
+            logicalWidth: this._logicalWidth,
+            logicalHeight: this._logicalHeight,
+            captureWidth: this._captureWidth,
+            captureHeight: this._captureHeight,
+            codec: "h264",
+            listeners: this.listenerCount("frame"),
+        };
+    }
+    // ============================================================================
+    // INTERNAL
+    // ============================================================================
+    spawnHelper(helperPath) {
+        this.helper = spawn(helperPath, [], {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Handle stdout — length-prefixed binary frames (v4 H.264)
+        this.helper.stdout.on("data", (chunk) => {
+            this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
+            this.processFrameBuffer();
+        });
+        // Handle stderr — log lines from Swift helper
+        const stderrRL = createInterface({ input: this.helper.stderr });
+        stderrRL.on("line", (line) => {
+            // Try to parse as JSON status, otherwise just log
+            try {
+                const status = JSON.parse(line);
+                this.handleHelperStatus(status);
+            }
+            catch {
+                console.log(`[screen-helper] ${line}`);
+                // Parse display info from log lines
+                const displayMatch = line.match(/Display: (\d+)x(\d+) logical/);
+                if (displayMatch) {
+                    this._logicalWidth = parseInt(displayMatch[1]);
+                    this._logicalHeight = parseInt(displayMatch[2]);
+                }
+                if (line.includes("SCStream started")) {
+                    this._capturing = true;
+                    this.emit("started");
+                }
+            }
+        });
+        this.helper.on("exit", (code) => {
+            console.log(`[screen-helper] Exited with code ${code}`);
+            this._capturing = false;
+            this.helper = null;
+            this.emit("stopped");
+        });
+        // Set initial FPS
+        this.injectInput({ type: "set_fps", fps: this.config.max_fps });
+    }
+    processFrameBuffer() {
+        while (true) {
+            // Need at least 4 bytes for the length prefix
+            if (this.stdoutBuffer.length < 4)
+                break;
+            const payloadLen = this.stdoutBuffer.readUInt32BE(0);
+            const totalLen = 4 + payloadLen;
+            // Wait for full frame
+            if (this.stdoutBuffer.length < totalLen)
+                break;
+            const frameData = Buffer.from(this.stdoutBuffer.subarray(0, totalLen));
+            this.stdoutBuffer = this.stdoutBuffer.subarray(totalLen);
+            // Parse v4 header to determine frame type and cache appropriately
+            if (frameData.length >= 27 && isV4Frame(frameData)) {
+                const header = parseFrameHeaderV4(frameData);
+                // Update dimensions from frame header
+                if (header.logicalWidth > 0) {
+                    this._logicalWidth = header.logicalWidth;
+                    this._logicalHeight = header.logicalHeight;
+                }
+                if (header.captureWidth > 0) {
+                    this._captureWidth = header.captureWidth;
+                    this._captureHeight = header.captureHeight;
+                }
+                switch (header.frameType) {
+                    case FrameType.CONFIG:
+                        this.latestConfig = frameData;
+                        this.emit("config", frameData);
+                        break;
+                    case FrameType.KEYFRAME:
+                        this.latestFrame = frameData;
+                        this.emit("frame", frameData);
+                        break;
+                    case FrameType.DELTA:
+                        this.latestFrame = frameData;
+                        this.emit("frame", frameData);
+                        break;
+                }
+            }
+            else {
+                // Legacy v3 frame — emit as-is for backwards compat
+                this.latestFrame = frameData;
+                this.emit("frame", frameData);
+            }
+        }
+    }
+    handleHelperStatus(status) {
+        switch (status.type) {
+            case "starting":
+                console.log(`[screen-helper] ${status.message}`);
+                break;
+            case "display_info":
+                this._logicalWidth = status.width || 0;
+                this._logicalHeight = status.height || 0;
+                console.log(`[screen-helper] Display: ${this._logicalWidth}x${this._logicalHeight}`);
+                break;
+            case "capturing":
+                this._capturing = true;
+                this.emit("started");
+                console.log(`[screen-helper] Capturing at ${status.fps} FPS`);
+                break;
+            case "permission_needed":
+                console.warn(`[screen-helper] ${status.message}`);
+                break;
+            case "error":
+                console.error(`[screen-helper] Error: ${status.error}`);
+                break;
+            case "stopping":
+                this._capturing = false;
+                break;
+        }
+        this.emit("status", status);
+    }
+}

package/dist/node/remote-desktop/protocol.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Remote Desktop Protocol — shared types between Node.js server and clients.
+ *
+ * v3 (legacy): 28-byte header, JPEG payload
+ * v4 (current): 27-byte header, H.264 NAL payload
+ */
+export declare const FRAME_HEADER_SIZE = 28;
+export interface FrameHeader {
+    seq: number;
+    timestamp: number;
+    width: number;
+    height: number;
+    quality: number;
+}
+export declare function parseFrameHeader(buf: Buffer): FrameHeader;
+export declare const FRAME_HEADER_SIZE_V4 = 27;
+export declare const NAL_DATA_OFFSET_V4 = 27;
+export declare enum FrameType {
+    KEYFRAME = 1,
+    DELTA = 2,
+    CONFIG = 3
+}
+export interface FrameHeaderV4 {
+    payloadLength: number;
+    frameType: FrameType;
+    seq: number;
+    timestamp: number;
+    logicalWidth: number;
+    logicalHeight: number;
+    captureWidth: number;
+    captureHeight: number;
+}
+export declare function parseFrameHeaderV4(buf: Buffer): FrameHeaderV4;
+export declare function isV4Frame(buf: Buffer): boolean;
+export interface InputEvent {
+    type: "mouse_move" | "mouse_down" | "mouse_up" | "mouse_drag" | "key_down" | "key_up" | "scroll" | "set_quality" | "set_fps";
+    x?: number;
+    y?: number;
+    button?: number;
+    keyCode?: number;
+    flags?: number;
+    scrollX?: number;
+    scrollY?: number;
+    quality?: number;
+    fps?: number;
+    clickCount?: number;
+}
+export interface SessionRequest {
+    type: "session_request";
+    token: string;
+    store_id: string;
+}
+export interface SessionResponse {
+    type: "session_response";
+    success: boolean;
+    session_id?: string;
+    width?: number;
+    height?: number;
+    fps?: number;
+    error?: string;
+}
+export interface SessionEnd {
+    type: "session_end";
+    reason: string;
+}
+export interface QualityChange {
+    type: "quality_change";
+    quality?: number;
+    fps?: number;
+}
+export interface HelperStatus {
+    type: "starting" | "display_info" | "capturing" | "error" | "stopping" | "permission_needed" | "quality_changed" | "fps_changed" | "input_error";
+    message?: string;
+    width?: number;
+    height?: number;
+    fps?: number;
+    quality?: number;
+    error?: string;
+}
+export interface RemoteDesktopRequest {
+    type: "remote_desktop_request";
+    target_node_id: string;
+    store_id: string;
+}
+export interface RemoteDesktopResponse {
+    type: "remote_desktop_response";
+    success: boolean;
+    session_id?: string;
+    error?: string;
+}
+export interface RemoteDesktopEnd {
+    type: "remote_desktop_end";
+    session_id: string;
+    reason: string;
+}
+export type RemoteDesktopMessage = SessionRequest | SessionResponse | SessionEnd | QualityChange | InputEvent | RemoteDesktopRequest | RemoteDesktopResponse | RemoteDesktopEnd;

package/dist/node/remote-desktop/protocol.js

@@ -0,0 +1,67 @@
+/**
+ * Remote Desktop Protocol — shared types between Node.js server and clients.
+ *
+ * v3 (legacy): 28-byte header, JPEG payload
+ * v4 (current): 27-byte header, H.264 NAL payload
+ */
+// ============================================================================
+// v3 Frame Header (legacy — JPEG)
+// ============================================================================
+// [0-3]   total payload length (big-endian uint32, excludes these 4 bytes)
+// [4-7]   sequence number (big-endian uint32)
+// [8-15]  timestamp ms (big-endian uint64)
+// [16-17] width (big-endian uint16)
+// [18-19] height (big-endian uint16)
+// [20-21] quality * 100 (big-endian uint16)
+// [22-27] reserved
+export const FRAME_HEADER_SIZE = 28;
+export function parseFrameHeader(buf) {
+    return {
+        seq: buf.readUInt32BE(4),
+        timestamp: Number(buf.readBigUInt64BE(8)),
+        width: buf.readUInt16BE(16),
+        height: buf.readUInt16BE(18),
+        quality: buf.readUInt16BE(20) / 100,
+    };
+}
+// ============================================================================
+// v4 Frame Header — H.264 hardware-encoded
+// ============================================================================
+// [0-3]   Payload length (big-endian uint32, includes header bytes 4-26 + NAL data)
+// [4]     Frame type: 0x01=keyframe, 0x02=delta, 0x03=config (SPS/PPS)
+// [5-8]   Sequence number (big-endian uint32)
+// [9-16]  Timestamp ms (big-endian uint64)
+// [17-18] Logical width (uint16 BE) — CGEvent coordinate space
+// [19-20] Logical height (uint16 BE)
+// [21-22] Capture width (uint16 BE) — actual encoded pixel dimensions
+// [23-24] Capture height (uint16 BE)
+// [25-26] Reserved
+// [27+]   H.264 NAL unit data
+export const FRAME_HEADER_SIZE_V4 = 27;
+export const NAL_DATA_OFFSET_V4 = 27;
+export var FrameType;
+(function (FrameType) {
+    FrameType[FrameType["KEYFRAME"] = 1] = "KEYFRAME";
+    FrameType[FrameType["DELTA"] = 2] = "DELTA";
+    FrameType[FrameType["CONFIG"] = 3] = "CONFIG";
+})(FrameType || (FrameType = {}));
+export function parseFrameHeaderV4(buf) {
+    return {
+        payloadLength: buf.readUInt32BE(0),
+        frameType: buf[4],
+        seq: buf.readUInt32BE(5),
+        timestamp: Number(buf.readBigUInt64BE(9)),
+        logicalWidth: buf.readUInt16BE(17),
+        logicalHeight: buf.readUInt16BE(19),
+        captureWidth: buf.readUInt16BE(21),
+        captureHeight: buf.readUInt16BE(23),
+    };
+}
+export function isV4Frame(buf) {
+    if (buf.length < 5)
+        return false;
+    const frameType = buf[4];
+    return frameType === FrameType.KEYFRAME
+        || frameType === FrameType.DELTA
+        || frameType === FrameType.CONFIG;
+}